{"version":3,"file":"2944.c9594898.js","mappings":"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","sources":["webpack://@finviz/website/../node_modules/@finviz/spine/index.js","webpack://@finviz/website/../node_modules/@finviz/spine/lib/spine.js","webpack://@finviz/website/../node_modules/copy-to-clipboard/index.js","webpack://@finviz/website/../node_modules/date-fns/esm/addBusinessDays/index.js","webpack://@finviz/website/../node_modules/date-fns/esm/isSaturday/index.js","webpack://@finviz/website/../node_modules/date-fns/esm/isSunday/index.js","webpack://@finviz/website/../node_modules/date-fns/esm/add/index.js","webpack://@finviz/website/../node_modules/date-fns/esm/eachDayOfInterval/index.js","webpack://@finviz/website/../node_modules/date-fns/esm/isSameMonth/index.js","webpack://@finviz/website/../node_modules/date-fns/esm/isSameWeek/index.js","webpack://@finviz/website/../node_modules/date-fns/esm/isWeekend/index.js","webpack://@finviz/website/../node_modules/date-fns/esm/isWithinInterval/index.js","webpack://@finviz/website/../node_modules/date-fns/esm/lastDayOfMonth/index.js","webpack://@finviz/website/../node_modules/date-fns/esm/lastDayOfWeek/index.js","webpack://@finviz/website/../node_modules/date-fns/esm/setMonth/index.js","webpack://@finviz/website/../node_modules/date-fns/esm/getDaysInMonth/index.js","webpack://@finviz/website/../node_modules/date-fns/esm/set/index.js","webpack://@finviz/website/../node_modules/date-fns/esm/startOfMonth/index.js","webpack://@finviz/website/../node_modules/date-fns/esm/startOfWeek/index.js","webpack://@finviz/website/../node_modules/date-fns/esm/startOfYear/index.js","webpack://@finviz/website/../node_modules/date-fns/esm/subYears/index.js","webpack://@finviz/website/../node_modules/date-fns/esm/addYears/index.js","webpack://@finviz/website/../node_modules/decode-uri-component/index.js","webpack://@finviz/website/../node_modules/filter-obj/index.js","webpack://@finviz/website/../node_modules/hammerjs/hammer.js","webpack://@finviz/website/../node_modules/lodash.flowright/index.js","webpack://@finviz/website/../node_modules/lodash.merge/index.js","webpack://@finviz/website/../node_modules/lodash.mergewith/index.js","webpack://@finviz/website/../node_modules/lodash.omit/index.js","webpack://@finviz/website/../node_modules/query-string/index.js","webpack://@finviz/website/../node_modules/re-resizable/lib/resizer.js","webpack://@finviz/website/../node_modules/re-resizable/lib/index.js","webpack://@finviz/website/../node_modules/react-dom/cjs/react-dom-server.browser.production.min.js","webpack://@finviz/website/../node_modules/react-dom/server.browser.js","webpack://@finviz/website/../node_modules/split-on-first/index.js","webpack://@finviz/website/../node_modules/strict-uri-encode/index.js","webpack://@finviz/website/../node_modules/toggle-selection/index.js","webpack://@finviz/website/../node_modules/core-js/internals/delete-property-or-throw.js","webpack://@finviz/website/../node_modules/core-js/internals/engine-is-browser.js","webpack://@finviz/website/../node_modules/core-js/internals/engine-is-deno.js","webpack://@finviz/website/../node_modules/core-js/internals/iterate.js","webpack://@finviz/website/../node_modules/core-js/internals/perform.js","webpack://@finviz/website/../node_modules/core-js/internals/promise-constructor-detection.js","webpack://@finviz/website/../node_modules/core-js/internals/promise-statics-incorrect-iteration.js","webpack://@finviz/website/../node_modules/core-js/modules/es.array.unshift.js","webpack://@finviz/website/../node_modules/core-js/modules/es.promise.all-settled.js","webpack://@finviz/website/../node_modules/core-js/modules/web.url.to-json.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/2P6ANLPF.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/32VQXIYR.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/IG6NVGLB.js","webpack://@finviz/website/../node_modules/@ariakit/core/esm/menu/menu-store.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/MAMNGFY7.js","webpack://@finviz/website/../node_modules/@ariakit/core/esm/__chunks/PXYVPXSS.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/HVBNG5AF.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/ULZ2KGZN.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/VBF5EZBB.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/menu/menu-button.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/menu/menu-provider.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/EF4Q2SSO.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/menu/menu.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/tab/tab-list.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/tab/tab-panel.js","webpack://@finviz/website/../node_modules/@ariakit/core/esm/tab/tab-store.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/CQMDBRG5.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/tab/tab-provider.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/tab/tab.js","webpack://@finviz/website/../node_modules/bezier-js/src/utils.js","webpack://@finviz/website/../node_modules/bezier-js/src/poly-bezier.js","webpack://@finviz/website/../node_modules/bezier-js/src/bezier.js"],"sourcesContent":["module.exports = require('./lib/spine');","// Generated by CoffeeScript 1.11.1\n\n/*\nSpine.js MVC library\nReleased under the MIT License\n */\n\n(function() {\n  var Collection, Events, Instance, Log, Model, Module, Singleton, Spine, association, createObject, makeArray, moduleKeywords, singularize, underscore,\n    slice = [].slice,\n    indexOf = [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; },\n    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },\n    hasProp = {}.hasOwnProperty;\n\n  Events = {\n    on: function(ev, callback) {\n      var base, evs, j, len, name;\n      evs = ev.split(' ');\n      if (!this.hasOwnProperty('_callbacks')) {\n        this._callbacks || (this._callbacks = {});\n      }\n      for (j = 0, len = evs.length; j < len; j++) {\n        name = evs[j];\n        (base = this._callbacks)[name] || (base[name] = []);\n        this._callbacks[name].push(callback);\n      }\n      return this;\n    },\n    one: function(ev, callback) {\n      var handler;\n      return this.on(ev, handler = function() {\n        this.off(ev, handler);\n        return callback.apply(this, arguments);\n      });\n    },\n    trigger: function() {\n      var args, callback, ev, j, len, list, ref;\n      args = 1 <= arguments.length ? slice.call(arguments, 0) : [];\n      ev = args.shift();\n      list = (ref = this._callbacks) != null ? ref[ev] : void 0;\n      if (!list) {\n        return;\n      }\n      for (j = 0, len = list.length; j < len; j++) {\n        callback = list[j];\n        if (callback.apply(this, args) === false) {\n          break;\n        }\n      }\n      return true;\n    },\n    listenTo: function(obj, ev, callback) {\n      obj.on(ev, callback);\n      this.listeningTo || (this.listeningTo = []);\n      this.listeningTo.push({\n        obj: obj,\n        ev: ev,\n        callback: callback\n      });\n      return this;\n    },\n    listenToOnce: function(obj, ev, callback) {\n      var handler, listeningToOnce;\n      listeningToOnce = this.listeningToOnce || (this.listeningToOnce = []);\n      obj.on(ev, handler = function() {\n        var i, idx, j, len, lt;\n        idx = -1;\n        for (i = j = 0, len = listeningToOnce.length; j < len; i = ++j) {\n          lt = listeningToOnce[i];\n          if (lt.obj === obj) {\n            if (lt.ev === ev && lt.callback === handler) {\n              idx = i;\n            }\n          }\n        }\n        obj.off(ev, handler);\n        if (idx !== -1) {\n          listeningToOnce.splice(idx, 1);\n        }\n        return callback.apply(this, arguments);\n      });\n      listeningToOnce.push({\n        obj: obj,\n        ev: ev,\n        callback: handler\n      });\n      return this;\n    },\n    stopListening: function(obj, events, callback) {\n      var e, ev, evts, idx, j, k, l, len, len1, len2, len3, listeningTo, lt, m, n, ref, ref1, ref2;\n      if (arguments.length === 0) {\n        ref = [this.listeningTo, this.listeningToOnce];\n        for (j = 0, len = ref.length; j < len; j++) {\n          listeningTo = ref[j];\n          if (!(listeningTo != null ? listeningTo.length : void 0)) {\n            continue;\n          }\n          for (k = 0, len1 = listeningTo.length; k < len1; k++) {\n            lt = listeningTo[k];\n            lt.obj.off(lt.ev, lt.callback);\n          }\n        }\n        this.listeningTo = void 0;\n        this.listeningToOnce = void 0;\n      } else if (obj) {\n        events = events ? events.split(' ') : [void 0];\n        ref1 = [this.listeningTo, this.listeningToOnce];\n        for (l = 0, len2 = ref1.length; l < len2; l++) {\n          listeningTo = ref1[l];\n          if (!listeningTo) {\n            continue;\n          }\n          for (m = 0, len3 = events.length; m < len3; m++) {\n            ev = events[m];\n            for (idx = n = ref2 = listeningTo.length - 1; ref2 <= 0 ? n <= 0 : n >= 0; idx = ref2 <= 0 ? ++n : --n) {\n              lt = listeningTo[idx];\n              if (lt.obj !== obj) {\n                continue;\n              }\n              if (callback && lt.callback !== callback) {\n                continue;\n              }\n              if ((!ev) || (ev === lt.ev)) {\n                lt.obj.off(lt.ev, lt.callback);\n                if (idx !== -1) {\n                  listeningTo.splice(idx, 1);\n                }\n              } else if (ev) {\n                evts = lt.ev.split(' ');\n                if (indexOf.call(evts, ev) >= 0) {\n                  evts = (function() {\n                    var len4, p, results;\n                    results = [];\n                    for (p = 0, len4 = evts.length; p < len4; p++) {\n                      e = evts[p];\n                      if (e !== ev) {\n                        results.push(e);\n                      }\n                    }\n                    return results;\n                  })();\n                  lt.ev = evts.join(' ').trim();\n                  lt.obj.off(ev, lt.callback);\n                }\n              }\n            }\n          }\n        }\n      }\n      return this;\n    },\n    off: function(ev, callback) {\n      var cb, evs, i, j, k, len, len1, list, name, ref;\n      if (arguments.length === 0) {\n        this._callbacks = {};\n        return this;\n      }\n      if (!ev) {\n        return this;\n      }\n      evs = ev.split(' ');\n      for (j = 0, len = evs.length; j < len; j++) {\n        name = evs[j];\n        list = (ref = this._callbacks) != null ? ref[name] : void 0;\n        if (!list) {\n          continue;\n        }\n        if (!callback) {\n          delete this._callbacks[name];\n          continue;\n        }\n        for (i = k = 0, len1 = list.length; k < len1; i = ++k) {\n          cb = list[i];\n          if (!(cb === callback)) {\n            continue;\n          }\n          list = list.slice();\n          list.splice(i, 1);\n          this._callbacks[name] = list;\n          break;\n        }\n      }\n      return this;\n    }\n  };\n\n  Events.bind = Events.on;\n\n  Events.unbind = Events.off;\n\n  Log = {\n    trace: true,\n    logPrefix: '(App)',\n    log: function() {\n      var args;\n      args = 1 <= arguments.length ? slice.call(arguments, 0) : [];\n      if (!this.trace) {\n        return;\n      }\n      if (this.logPrefix) {\n        args.unshift(this.logPrefix);\n      }\n      if (typeof console !== \"undefined\" && console !== null) {\n        if (typeof console.log === \"function\") {\n          console.log.apply(console, args);\n        }\n      }\n      return this;\n    }\n  };\n\n  moduleKeywords = ['included', 'extended'];\n\n  Module = (function() {\n    Module.include = function(obj) {\n      var key, ref, value;\n      if (!obj) {\n        throw new Error('include(obj) requires obj');\n      }\n      for (key in obj) {\n        value = obj[key];\n        if (indexOf.call(moduleKeywords, key) < 0) {\n          this.prototype[key] = value;\n        }\n      }\n      if ((ref = obj.included) != null) {\n        ref.apply(this);\n      }\n      return this;\n    };\n\n    Module.extend = function(obj) {\n      var key, ref, value;\n      if (!obj) {\n        throw new Error('extend(obj) requires obj');\n      }\n      for (key in obj) {\n        value = obj[key];\n        if (indexOf.call(moduleKeywords, key) < 0) {\n          this[key] = value;\n        }\n      }\n      if ((ref = obj.extended) != null) {\n        ref.apply(this);\n      }\n      return this;\n    };\n\n    Module.extend(Events);\n\n    Module.include(Events);\n\n    Module.proxy = function(func) {\n      return (function(_this) {\n        return function() {\n          return func.apply(_this, arguments);\n        };\n      })(this);\n    };\n\n    Module.prototype.proxy = function(func) {\n      return (function(_this) {\n        return function() {\n          return func.apply(_this, arguments);\n        };\n      })(this);\n    };\n\n    function Module() {\n      if (typeof this.init === \"function\") {\n        this.init.apply(this, arguments);\n      }\n    }\n\n    return Module;\n\n  })();\n\n  Model = (function(superClass) {\n    extend(Model, superClass);\n\n    Model.records = [];\n\n    Model.irecords = {};\n\n    Model.attributes = [];\n\n    Model.configure = function() {\n      var attributes, name;\n      name = arguments[0], attributes = 2 <= arguments.length ? slice.call(arguments, 1) : [];\n      this.className = name;\n      this.deleteAll();\n      if (attributes.length) {\n        this.attributes = attributes;\n      }\n      this.attributes && (this.attributes = makeArray(this.attributes));\n      this.attributes || (this.attributes = []);\n      this.off();\n      return this;\n    };\n\n    Model.toString = function() {\n      return this.className + \"(\" + (this.attributes.join(\", \")) + \")\";\n    };\n\n    Model.find = function(id, notFound) {\n      var ref;\n      if (notFound == null) {\n        notFound = this.notFound;\n      }\n      return ((ref = this.irecords[id]) != null ? ref.clone() : void 0) || (notFound != null ? notFound.call(this, id) : void 0);\n    };\n\n    Model.findAll = function(ids, notFound) {\n      var id, j, len, results;\n      results = [];\n      for (j = 0, len = ids.length; j < len; j++) {\n        id = ids[j];\n        if (this.find(id, notFound)) {\n          results.push(this.find(id));\n        }\n      }\n      return results;\n    };\n\n    Model.notFound = function(id) {\n      return null;\n    };\n\n    Model.exists = function(id) {\n      return Boolean(this.irecords[id]);\n    };\n\n    Model.addRecord = function(record, idx) {\n      var root;\n      if (root = this.irecords[record.id || record.cid]) {\n        root.refresh(record);\n      } else {\n        record.id || (record.id = record.cid);\n        this.irecords[record.id] = this.irecords[record.cid] = record;\n        if (idx !== void 0) {\n          this.records.splice(idx, 0, record);\n        } else {\n          this.records.push(record);\n        }\n      }\n      return record;\n    };\n\n    Model.refresh = function(values, options) {\n      var j, len, record, records, result;\n      if (options == null) {\n        options = {};\n      }\n      if (options.clear) {\n        this.deleteAll();\n      }\n      records = this.fromJSON(values);\n      if (!Array.isArray(records)) {\n        records = [records];\n      }\n      for (j = 0, len = records.length; j < len; j++) {\n        record = records[j];\n        this.addRecord(record);\n      }\n      this.sort();\n      result = this.cloneArray(records);\n      this.trigger('refresh', result, options);\n      return result;\n    };\n\n    Model.select = function(callback) {\n      var j, len, record, ref, results;\n      ref = this.records;\n      results = [];\n      for (j = 0, len = ref.length; j < len; j++) {\n        record = ref[j];\n        if (callback(record)) {\n          results.push(record.clone());\n        }\n      }\n      return results;\n    };\n\n    Model.findByAttribute = function(name, value) {\n      var j, len, record, ref;\n      ref = this.records;\n      for (j = 0, len = ref.length; j < len; j++) {\n        record = ref[j];\n        if (record[name] === value) {\n          return record.clone();\n        }\n      }\n      return null;\n    };\n\n    Model.findAllByAttribute = function(name, value) {\n      return this.select(function(item) {\n        return item[name] === value;\n      });\n    };\n\n    Model.each = function(callback) {\n      var j, len, record, ref, results;\n      ref = this.records;\n      results = [];\n      for (j = 0, len = ref.length; j < len; j++) {\n        record = ref[j];\n        results.push(callback(record.clone()));\n      }\n      return results;\n    };\n\n    Model.all = function() {\n      return this.cloneArray(this.records);\n    };\n\n    Model.slice = function(begin, end) {\n      if (begin == null) {\n        begin = 0;\n      }\n      return this.cloneArray(this.records.slice(begin, end));\n    };\n\n    Model.first = function(end) {\n      var ref;\n      if (end == null) {\n        end = 1;\n      }\n      if (end > 1) {\n        return this.cloneArray(this.records.slice(0, end));\n      } else {\n        return (ref = this.records[0]) != null ? ref.clone() : void 0;\n      }\n    };\n\n    Model.last = function(begin) {\n      var ref;\n      if (typeof begin === 'number') {\n        return this.cloneArray(this.records.slice(-begin));\n      } else {\n        return (ref = this.records[this.records.length - 1]) != null ? ref.clone() : void 0;\n      }\n    };\n\n    Model.count = function() {\n      return this.records.length;\n    };\n\n    Model.deleteAll = function() {\n      this.records = [];\n      return this.irecords = {};\n    };\n\n    Model.destroyAll = function(options) {\n      var j, len, record, ref, results;\n      ref = this.records;\n      results = [];\n      for (j = 0, len = ref.length; j < len; j++) {\n        record = ref[j];\n        results.push(record.destroy(options));\n      }\n      return results;\n    };\n\n    Model.update = function(id, atts, options) {\n      return this.find(id).updateAttributes(atts, options);\n    };\n\n    Model.create = function(atts, options) {\n      var record;\n      record = new this(atts);\n      return record.save(options);\n    };\n\n    Model.destroy = function(id, options) {\n      var ref;\n      return (ref = this.find(id)) != null ? ref.destroy(options) : void 0;\n    };\n\n    Model.change = function(callbackOrParams) {\n      if (typeof callbackOrParams === 'function') {\n        return this.on('change', callbackOrParams);\n      } else {\n        return this.trigger.apply(this, ['change'].concat(slice.call(arguments)));\n      }\n    };\n\n    Model.fetch = function(callbackOrParams) {\n      if (typeof callbackOrParams === 'function') {\n        return this.on('fetch', callbackOrParams);\n      } else {\n        return this.trigger.apply(this, ['fetch'].concat(slice.call(arguments)));\n      }\n    };\n\n    Model.toJSON = function() {\n      return this.records;\n    };\n\n    Model.beforeFromJSON = function(objects) {\n      return objects;\n    };\n\n    Model.fromJSON = function(objects) {\n      var j, len, results, value;\n      if (!objects) {\n        return;\n      }\n      if (typeof objects === 'string') {\n        objects = JSON.parse(objects);\n      }\n      objects = this.beforeFromJSON(objects);\n      if (Array.isArray(objects)) {\n        results = [];\n        for (j = 0, len = objects.length; j < len; j++) {\n          value = objects[j];\n          if (value instanceof this) {\n            results.push(value);\n          } else {\n            results.push(new this(value));\n          }\n        }\n        return results;\n      } else {\n        if (objects instanceof this) {\n          return objects;\n        }\n        return new this(objects);\n      }\n    };\n\n    Model.sort = function() {\n      if (this.comparator) {\n        this.records.sort(this.comparator);\n      }\n      return this;\n    };\n\n    Model.cloneArray = function(array) {\n      var j, len, results, value;\n      results = [];\n      for (j = 0, len = array.length; j < len; j++) {\n        value = array[j];\n        results.push(value.clone());\n      }\n      return results;\n    };\n\n    Model.idCounter = 0;\n\n    Model.uid = function(prefix) {\n      var uid;\n      if (prefix == null) {\n        prefix = '';\n      }\n      uid = prefix + this.idCounter++;\n      if (this.exists(uid)) {\n        uid = this.uid(prefix);\n      }\n      return uid;\n    };\n\n    function Model(atts) {\n      Model.__super__.constructor.apply(this, arguments);\n      if ((this.constructor.uuid != null) && typeof this.constructor.uuid === 'function') {\n        this.cid = this.constructor.uuid();\n        if (!this.id) {\n          this.id = this.cid;\n        }\n      } else {\n        this.cid = (atts != null ? atts.cid : void 0) || this.constructor.uid('c-');\n      }\n      if (atts) {\n        this.load(atts);\n      }\n    }\n\n    Model.prototype.isNew = function() {\n      return !this.exists();\n    };\n\n    Model.prototype.isValid = function() {\n      return !this.validate();\n    };\n\n    Model.prototype.validate = function() {};\n\n    Model.prototype.load = function(atts) {\n      var key, value;\n      if (atts.id) {\n        this.id = atts.id;\n      }\n      for (key in atts) {\n        value = atts[key];\n        if (key === '_callbacks') {\n          continue;\n        }\n        if (typeof this[key] === 'function') {\n          if (typeof value === 'function') {\n            continue;\n          }\n          this[key](value);\n        } else {\n          this[key] = value;\n        }\n      }\n      return this;\n    };\n\n    Model.prototype.attributes = function() {\n      var j, key, len, ref, result;\n      result = {};\n      ref = this.constructor.attributes;\n      for (j = 0, len = ref.length; j < len; j++) {\n        key = ref[j];\n        if (key in this) {\n          if (typeof this[key] === 'function') {\n            result[key] = this[key]();\n          } else {\n            result[key] = this[key];\n          }\n        }\n      }\n      if (this.id) {\n        result.id = this.id;\n      }\n      return result;\n    };\n\n    Model.prototype.eql = function(rec) {\n      return rec && rec.constructor === this.constructor && ((rec.cid === this.cid) || (rec.id && rec.id === this.id));\n    };\n\n    Model.prototype.save = function(options) {\n      var error, record;\n      if (options == null) {\n        options = {};\n      }\n      if (options.validate !== false) {\n        error = this.validate();\n        if (error) {\n          this.trigger('error', this, error);\n          return false;\n        }\n      }\n      this.trigger('beforeSave', this, options);\n      record = this.isNew() ? this.create(options) : this.update(options);\n      this.stripCloneAttrs();\n      this.trigger('save', record, options);\n      return record;\n    };\n\n    Model.prototype.stripCloneAttrs = function() {\n      var key, ref, value;\n      if (this.hasOwnProperty('cid')) {\n        return;\n      }\n      ref = this;\n      for (key in ref) {\n        if (!hasProp.call(ref, key)) continue;\n        value = ref[key];\n        if (indexOf.call(this.constructor.attributes, key) >= 0) {\n          delete this[key];\n        }\n      }\n      return this;\n    };\n\n    Model.prototype.updateAttribute = function(name, value, options) {\n      var atts;\n      atts = {};\n      atts[name] = value;\n      return this.updateAttributes(atts, options);\n    };\n\n    Model.prototype.updateAttributes = function(atts, options) {\n      this.load(atts);\n      return this.save(options);\n    };\n\n    Model.prototype.changeID = function(id) {\n      var records;\n      if (id === this.id) {\n        return;\n      }\n      records = this.constructor.irecords;\n      records[id] = records[this.id];\n      if (this.cid !== this.id) {\n        delete records[this.id];\n      }\n      return this.id = id;\n    };\n\n    Model.prototype.remove = function(options) {\n      var i, j, len, record, records;\n      if (options == null) {\n        options = {};\n      }\n      records = this.constructor.records.slice(0);\n      for (i = j = 0, len = records.length; j < len; i = ++j) {\n        record = records[i];\n        if (!(this.eql(record))) {\n          continue;\n        }\n        records.splice(i, 1);\n        break;\n      }\n      this.constructor.records = records;\n      if (options.clear) {\n        delete this.constructor.irecords[this.id];\n        return delete this.constructor.irecords[this.cid];\n      }\n    };\n\n    Model.prototype.destroy = function(options) {\n      if (options == null) {\n        options = {};\n      }\n      if (options.clear == null) {\n        options.clear = true;\n      }\n      this.trigger('beforeDestroy', this, options);\n      this.remove(options);\n      this.destroyed = true;\n      this.trigger('destroy', this, options);\n      this.trigger('change', this, 'destroy', options);\n      if (this.listeningTo) {\n        this.stopListening();\n      }\n      this.off();\n      return this;\n    };\n\n    Model.prototype.dup = function(newRecord) {\n      var atts, record;\n      if (newRecord == null) {\n        newRecord = true;\n      }\n      atts = this.attributes();\n      if (newRecord) {\n        delete atts.id;\n      } else {\n        atts.cid = this.cid;\n      }\n      record = new this.constructor(atts);\n      if (!newRecord) {\n        this._callbacks && (record._callbacks = this._callbacks);\n      }\n      return record;\n    };\n\n    Model.prototype.clone = function() {\n      return createObject(this);\n    };\n\n    Model.prototype.reload = function() {\n      var original;\n      if (this.isNew()) {\n        return this;\n      }\n      original = this.constructor.find(this.id);\n      this.load(original.attributes());\n      return original;\n    };\n\n    Model.prototype.refresh = function(atts) {\n      atts = this.constructor.fromJSON(atts);\n      if (atts.id && this.id !== atts.id) {\n        this.changeID(atts.id);\n      }\n      this.constructor.irecords[this.id].load(atts);\n      this.trigger('refresh', this);\n      this.trigger('change', this, 'refresh');\n      return this;\n    };\n\n    Model.prototype.toJSON = function() {\n      return this.attributes();\n    };\n\n    Model.prototype.toString = function() {\n      return \"<\" + this.constructor.className + \" (\" + (JSON.stringify(this)) + \")>\";\n    };\n\n    Model.prototype.exists = function() {\n      return this.constructor.exists(this.id);\n    };\n\n    Model.prototype.update = function(options) {\n      var clone, records;\n      this.trigger('beforeUpdate', this, options);\n      records = this.constructor.irecords;\n      records[this.id].load(this.attributes());\n      this.constructor.sort();\n      clone = records[this.id].clone();\n      clone.trigger('update', clone, options);\n      clone.trigger('change', clone, 'update', options);\n      return clone;\n    };\n\n    Model.prototype.create = function(options) {\n      var clone, record;\n      this.trigger('beforeCreate', this, options);\n      this.id || (this.id = this.cid);\n      record = this.dup(false);\n      this.constructor.addRecord(record, options.idx);\n      this.constructor.sort();\n      clone = record.clone();\n      clone.trigger('create', clone, options);\n      clone.trigger('change', clone, 'create', options);\n      return clone;\n    };\n\n    Model.prototype.on = function() {\n      var record;\n      record = this.constructor.irecords[this.id] || this;\n      return Events.on.apply(record, arguments);\n    };\n\n    Model.prototype.one = function() {\n      var record;\n      record = this.constructor.irecords[this.id] || this;\n      return Events.one.apply(record, arguments);\n    };\n\n    Model.prototype.off = function() {\n      var record;\n      record = this.constructor.irecords[this.id] || this;\n      return Events.off.apply(record, arguments);\n    };\n\n    Model.prototype.trigger = function() {\n      var ref;\n      Events.trigger.apply(this, arguments);\n      if (arguments[0] === 'refresh') {\n        return true;\n      }\n      return (ref = this.constructor).trigger.apply(ref, arguments);\n    };\n\n    return Model;\n\n  })(Module);\n\n  Model.prototype.bind = Model.prototype.on;\n\n  Model.prototype.unbind = Model.prototype.off;\n\n  createObject = Object.create || function(o) {\n    var Func;\n    Func = function() {};\n    Func.prototype = o;\n    return new Func();\n  };\n\n  makeArray = function(args) {\n    return Array.prototype.slice.call(args, 0);\n  };\n\n  Spine = this.Spine = {};\n\n  if (typeof module !== \"undefined\" && module !== null) {\n    module.exports = Spine;\n  }\n\n  Spine.version = '2.1.0';\n\n  Spine.Events = Events;\n\n  Spine.Log = Log;\n\n  Spine.Module = Module;\n\n  Spine.Model = Model;\n\n  Module.extend.call(Spine, Events);\n\n  Module.create = Module.sub = Model.sub = function(instances, statics) {\n    var Result;\n    Result = (function(superClass) {\n      extend(Result, superClass);\n\n      function Result() {\n        return Result.__super__.constructor.apply(this, arguments);\n      }\n\n      return Result;\n\n    })(this);\n    if (instances) {\n      Result.include(instances);\n    }\n    if (statics) {\n      Result.extend(statics);\n    }\n    if (typeof Result.off === \"function\") {\n      Result.off();\n    }\n    return Result;\n  };\n\n  Model.setup = function(name, attributes) {\n    var Instance;\n    if (attributes == null) {\n      attributes = [];\n    }\n    Instance = (function(superClass) {\n      extend(Instance, superClass);\n\n      function Instance() {\n        return Instance.__super__.constructor.apply(this, arguments);\n      }\n\n      return Instance;\n\n    })(this);\n    Instance.configure.apply(Instance, [name].concat(slice.call(attributes)));\n    return Instance;\n  };\n\n  Spine.Class = Module;\n\n  Collection = (function(superClass) {\n    extend(Collection, superClass);\n\n    function Collection(options) {\n      var key, value;\n      if (options == null) {\n        options = {};\n      }\n      for (key in options) {\n        value = options[key];\n        this[key] = value;\n      }\n    }\n\n    Collection.prototype.all = function() {\n      return this.model.select((function(_this) {\n        return function(rec) {\n          return _this.associated(rec);\n        };\n      })(this));\n    };\n\n    Collection.prototype.first = function() {\n      return this.all()[0];\n    };\n\n    Collection.prototype.last = function() {\n      var values;\n      values = this.all();\n      return values[values.length - 1];\n    };\n\n    Collection.prototype.count = function() {\n      return this.all().length;\n    };\n\n    Collection.prototype.find = function(id, notFound) {\n      var records;\n      if (notFound == null) {\n        notFound = this.model.notFound;\n      }\n      records = this.select((function(_this) {\n        return function(rec) {\n          return (\"\" + rec.id) === (\"\" + id);\n        };\n      })(this));\n      return records[0] || (typeof notFound === \"function\" ? notFound(id) : void 0);\n    };\n\n    Collection.prototype.findAllByAttribute = function(name, value) {\n      return this.model.select((function(_this) {\n        return function(rec) {\n          return _this.associated(rec) && rec[name] === value;\n        };\n      })(this));\n    };\n\n    Collection.prototype.findByAttribute = function(name, value) {\n      return this.findAllByAttribute(name, value)[0];\n    };\n\n    Collection.prototype.select = function(cb) {\n      return this.model.select((function(_this) {\n        return function(rec) {\n          return _this.associated(rec) && cb(rec);\n        };\n      })(this));\n    };\n\n    Collection.prototype.refresh = function(values) {\n      var i, j, k, l, len, len1, len2, match, record, ref, ref1;\n      if (values == null) {\n        return this;\n      }\n      ref = this.all();\n      for (j = 0, len = ref.length; j < len; j++) {\n        record = ref[j];\n        delete this.model.irecords[record.id];\n        ref1 = this.model.records;\n        for (i = k = 0, len1 = ref1.length; k < len1; i = ++k) {\n          match = ref1[i];\n          if (!(match.id === record.id)) {\n            continue;\n          }\n          this.model.records.splice(i, 1);\n          break;\n        }\n      }\n      if (!Array.isArray(values)) {\n        values = [values];\n      }\n      for (l = 0, len2 = values.length; l < len2; l++) {\n        record = values[l];\n        record.newRecord = false;\n        record[this.fkey] = this.record.id;\n      }\n      this.model.refresh(values);\n      return this;\n    };\n\n    Collection.prototype.create = function(record, options) {\n      record[this.fkey] = this.record.id;\n      return this.model.create(record, options);\n    };\n\n    Collection.prototype.add = function(record, options) {\n      return record.updateAttribute(this.fkey, this.record.id, options);\n    };\n\n    Collection.prototype.remove = function(record, options) {\n      return record.updateAttribute(this.fkey, null, options);\n    };\n\n    Collection.prototype.associated = function(record) {\n      return record[this.fkey] === this.record.id;\n    };\n\n    return Collection;\n\n  })(Spine.Module);\n\n  Instance = (function(superClass) {\n    extend(Instance, superClass);\n\n    function Instance(options) {\n      var key, value;\n      if (options == null) {\n        options = {};\n      }\n      for (key in options) {\n        value = options[key];\n        this[key] = value;\n      }\n    }\n\n    Instance.prototype.find = function() {\n      return this.model.find(this.record[this.fkey]);\n    };\n\n    Instance.prototype.update = function(value) {\n      if (value == null) {\n        return this;\n      }\n      value = this.model.refresh(value)[0];\n      this.record[this.fkey] = value && value.id;\n      return this;\n    };\n\n    return Instance;\n\n  })(Spine.Module);\n\n  Singleton = (function(superClass) {\n    extend(Singleton, superClass);\n\n    function Singleton(options) {\n      var key, value;\n      if (options == null) {\n        options = {};\n      }\n      for (key in options) {\n        value = options[key];\n        this[key] = value;\n      }\n    }\n\n    Singleton.prototype.find = function() {\n      return this.record.id && this.model.findByAttribute(this.fkey, this.record.id);\n    };\n\n    Singleton.prototype.update = function(value) {\n      if (value == null) {\n        return this;\n      }\n      value[this.fkey] = this.record.id;\n      this.model.refresh(value);\n      return this;\n    };\n\n    return Singleton;\n\n  })(Spine.Module);\n\n  singularize = function(str) {\n    return str.replace(/s$/, '');\n  };\n\n  underscore = function(str) {\n    return str.replace(/::/g, '/').replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2').replace(/([a-z\\d])([A-Z])/g, '$1_$2').replace(/(-|\\.)/g, '_').toLowerCase();\n  };\n\n  association = function(name, model, record, fkey, Ctor) {\n    return new Ctor({\n      name: name,\n      model: model,\n      record: record,\n      fkey: fkey\n    });\n  };\n\n  Spine.Model.extend({\n    hasMany: function(name, model, fkey) {\n      if (fkey == null) {\n        fkey = (underscore(this.className)) + \"_id\";\n      }\n      return this.prototype[name] = function(value) {\n        return association(name, model, this, fkey, Collection).refresh(value);\n      };\n    },\n    belongsTo: function(name, model, fkey) {\n      if (fkey == null) {\n        fkey = (underscore(singularize(name))) + \"_id\";\n      }\n      this.prototype[name] = function(value) {\n        return association(name, model, this, fkey, Instance).update(value).find();\n      };\n      return this.attributes.push(fkey);\n    },\n    hasOne: function(name, model, fkey) {\n      if (fkey == null) {\n        fkey = (underscore(this.className)) + \"_id\";\n      }\n      return this.prototype[name] = function(value) {\n        return association(name, model, this, fkey, Singleton).update(value).find();\n      };\n    }\n  });\n\n  Spine.Collection = Collection;\n\n  Spine.Singleton = Singleton;\n\n  Spine.Instance = Instance;\n\n}).call(this);\n\n//# sourceMappingURL=spine.js.map\n","\"use strict\";\n\nvar deselectCurrent = require(\"toggle-selection\");\n\nvar clipboardToIE11Formatting = {\n  \"text/plain\": \"Text\",\n  \"text/html\": \"Url\",\n  \"default\": \"Text\"\n}\n\nvar defaultMessage = \"Copy to clipboard: #{key}, Enter\";\n\nfunction format(message) {\n  var copyKey = (/mac os x/i.test(navigator.userAgent) ? \"⌘\" : \"Ctrl\") + \"+C\";\n  return message.replace(/#{\\s*key\\s*}/g, copyKey);\n}\n\nfunction copy(text, options) {\n  var debug,\n    message,\n    reselectPrevious,\n    range,\n    selection,\n    mark,\n    success = false;\n  if (!options) {\n    options = {};\n  }\n  debug = options.debug || false;\n  try {\n    reselectPrevious = deselectCurrent();\n\n    range = document.createRange();\n    selection = document.getSelection();\n\n    mark = document.createElement(\"span\");\n    mark.textContent = text;\n    // reset user styles for span element\n    mark.style.all = \"unset\";\n    // prevents scrolling to the end of the page\n    mark.style.position = \"fixed\";\n    mark.style.top = 0;\n    mark.style.clip = \"rect(0, 0, 0, 0)\";\n    // used to preserve spaces and line breaks\n    mark.style.whiteSpace = \"pre\";\n    // do not inherit user-select (it may be `none`)\n    mark.style.webkitUserSelect = \"text\";\n    mark.style.MozUserSelect = \"text\";\n    mark.style.msUserSelect = \"text\";\n    mark.style.userSelect = \"text\";\n    mark.addEventListener(\"copy\", function(e) {\n      e.stopPropagation();\n      if (options.format) {\n        e.preventDefault();\n        if (typeof e.clipboardData === \"undefined\") { // IE 11\n          debug && console.warn(\"unable to use e.clipboardData\");\n          debug && console.warn(\"trying IE specific stuff\");\n          window.clipboardData.clearData();\n          var format = clipboardToIE11Formatting[options.format] || clipboardToIE11Formatting[\"default\"]\n          window.clipboardData.setData(format, text);\n        } else { // all other browsers\n          e.clipboardData.clearData();\n          e.clipboardData.setData(options.format, text);\n        }\n      }\n      if (options.onCopy) {\n        e.preventDefault();\n        options.onCopy(e.clipboardData);\n      }\n    });\n\n    document.body.appendChild(mark);\n\n    range.selectNodeContents(mark);\n    selection.addRange(range);\n\n    var successful = document.execCommand(\"copy\");\n    if (!successful) {\n      throw new Error(\"copy command was unsuccessful\");\n    }\n    success = true;\n  } catch (err) {\n    debug && console.error(\"unable to copy using execCommand: \", err);\n    debug && console.warn(\"trying IE specific stuff\");\n    try {\n      window.clipboardData.setData(options.format || \"text\", text);\n      options.onCopy && options.onCopy(window.clipboardData);\n      success = true;\n    } catch (err) {\n      debug && console.error(\"unable to copy using clipboardData: \", err);\n      debug && console.error(\"falling back to prompt\");\n      message = format(\"message\" in options ? options.message : defaultMessage);\n      window.prompt(message, text);\n    }\n  } finally {\n    if (selection) {\n      if (typeof selection.removeRange == \"function\") {\n        selection.removeRange(range);\n      } else {\n        selection.removeAllRanges();\n      }\n    }\n\n    if (mark) {\n      document.body.removeChild(mark);\n    }\n    reselectPrevious();\n  }\n\n  return success;\n}\n\nmodule.exports = copy;\n","import isWeekend from \"../isWeekend/index.js\";\nimport toDate from \"../toDate/index.js\";\nimport toInteger from \"../_lib/toInteger/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\nimport isSunday from \"../isSunday/index.js\";\nimport isSaturday from \"../isSaturday/index.js\";\n/**\n * @name addBusinessDays\n * @category Day Helpers\n * @summary Add the specified number of business days (mon - fri) to the given date.\n *\n * @description\n * Add the specified number of business days (mon - fri) to the given date, ignoring weekends.\n *\n * @param {Date|Number} date - the date to be changed\n * @param {Number} amount - the amount of business days to be added. Positive decimals will be rounded using `Math.floor`, decimals less than zero will be rounded using `Math.ceil`.\n * @returns {Date} the new date with the business days added\n * @throws {TypeError} 2 arguments required\n *\n * @example\n * // Add 10 business days to 1 September 2014:\n * const result = addBusinessDays(new Date(2014, 8, 1), 10)\n * //=> Mon Sep 15 2014 00:00:00 (skipped weekend days)\n */\n\nexport default function addBusinessDays(dirtyDate, dirtyAmount) {\n  requiredArgs(2, arguments);\n  var date = toDate(dirtyDate);\n  var startedOnWeekend = isWeekend(date);\n  var amount = toInteger(dirtyAmount);\n  if (isNaN(amount)) return new Date(NaN);\n  var hours = date.getHours();\n  var sign = amount < 0 ? -1 : 1;\n  var fullWeeks = toInteger(amount / 5);\n  date.setDate(date.getDate() + fullWeeks * 7); // Get remaining days not part of a full week\n\n  var restDays = Math.abs(amount % 5); // Loops over remaining days\n\n  while (restDays > 0) {\n    date.setDate(date.getDate() + sign);\n    if (!isWeekend(date)) restDays -= 1;\n  } // If the date is a weekend day and we reduce a dividable of\n  // 5 from it, we land on a weekend date.\n  // To counter this, we add days accordingly to land on the next business day\n\n\n  if (startedOnWeekend && isWeekend(date) && amount !== 0) {\n    // If we're reducing days, we want to add days until we land on a weekday\n    // If we're adding days we want to reduce days until we land on a weekday\n    if (isSaturday(date)) date.setDate(date.getDate() + (sign < 0 ? 2 : -1));\n    if (isSunday(date)) date.setDate(date.getDate() + (sign < 0 ? 1 : -2));\n  } // Restore hours to avoid DST lag\n\n\n  date.setHours(hours);\n  return date;\n}","import toDate from \"../toDate/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\n/**\n * @name isSaturday\n * @category Weekday Helpers\n * @summary Is the given date Saturday?\n *\n * @description\n * Is the given date Saturday?\n *\n * ### v2.0.0 breaking changes:\n *\n * - [Changes that are common for the whole library](https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#Common-Changes).\n *\n * @param {Date|Number} date - the date to check\n * @returns {Boolean} the date is Saturday\n * @throws {TypeError} 1 argument required\n *\n * @example\n * // Is 27 September 2014 Saturday?\n * var result = isSaturday(new Date(2014, 8, 27))\n * //=> true\n */\n\nexport default function isSaturday(dirtyDate) {\n  requiredArgs(1, arguments);\n  return toDate(dirtyDate).getDay() === 6;\n}","import toDate from \"../toDate/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\n/**\n * @name isSunday\n * @category Weekday Helpers\n * @summary Is the given date Sunday?\n *\n * @description\n * Is the given date Sunday?\n *\n * ### v2.0.0 breaking changes:\n *\n * - [Changes that are common for the whole library](https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#Common-Changes).\n *\n * @param {Date|Number} date - the date to check\n * @returns {Boolean} the date is Sunday\n * @throws {TypeError} 1 argument required\n *\n * @example\n * // Is 21 September 2014 Sunday?\n * var result = isSunday(new Date(2014, 8, 21))\n * //=> true\n */\n\nexport default function isSunday(dirtyDate) {\n  requiredArgs(1, arguments);\n  return toDate(dirtyDate).getDay() === 0;\n}","import addDays from \"../addDays/index.js\";\nimport addMonths from \"../addMonths/index.js\";\nimport toDate from \"../toDate/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\nimport toInteger from \"../_lib/toInteger/index.js\";\n\n/**\n * @name add\n * @category Common Helpers\n * @summary Add the specified years, months, weeks, days, hours, minutes and seconds to the given date.\n *\n * @description\n * Add the specified years, months, weeks, days, hours, minutes and seconds to the given date.\n *\n * @param {Date|Number} date - the date to be changed\n * @param {Duration} duration - the object with years, months, weeks, days, hours, minutes and seconds to be added. Positive decimals will be rounded using `Math.floor`, decimals less than zero will be rounded using `Math.ceil`.\n *\n * | Key            | Description                        |\n * |----------------|------------------------------------|\n * | years          | Amount of years to be added        |\n * | months         | Amount of months to be added       |\n * | weeks          | Amount of weeks to be added        |\n * | days           | Amount of days to be added         |\n * | hours          | Amount of hours to be added        |\n * | minutes        | Amount of minutes to be added      |\n * | seconds        | Amount of seconds to be added      |\n *\n * All values default to 0\n *\n * @returns {Date} the new date with the seconds added\n * @throws {TypeError} 2 arguments required\n *\n * @example\n * // Add the following duration to 1 September 2014, 10:19:50\n * const result = add(new Date(2014, 8, 1, 10, 19, 50), {\n *   years: 2,\n *   months: 9,\n *   weeks: 1,\n *   days: 7,\n *   hours: 5,\n *   minutes: 9,\n *   seconds: 30,\n * })\n * //=> Thu Jun 15 2017 15:29:20\n */\nexport default function add(dirtyDate, duration) {\n  requiredArgs(2, arguments);\n  if (!duration || typeof duration !== 'object') return new Date(NaN);\n  var years = duration.years ? toInteger(duration.years) : 0;\n  var months = duration.months ? toInteger(duration.months) : 0;\n  var weeks = duration.weeks ? toInteger(duration.weeks) : 0;\n  var days = duration.days ? toInteger(duration.days) : 0;\n  var hours = duration.hours ? toInteger(duration.hours) : 0;\n  var minutes = duration.minutes ? toInteger(duration.minutes) : 0;\n  var seconds = duration.seconds ? toInteger(duration.seconds) : 0; // Add years and months\n\n  var date = toDate(dirtyDate);\n  var dateWithMonths = months || years ? addMonths(date, months + years * 12) : date; // Add weeks and days\n\n  var dateWithDays = days || weeks ? addDays(dateWithMonths, days + weeks * 7) : dateWithMonths; // Add days, hours, minutes and seconds\n\n  var minutesToAdd = minutes + hours * 60;\n  var secondsToAdd = seconds + minutesToAdd * 60;\n  var msToAdd = secondsToAdd * 1000;\n  var finalDate = new Date(dateWithDays.getTime() + msToAdd);\n  return finalDate;\n}","import toDate from \"../toDate/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\n/**\n * @name eachDayOfInterval\n * @category Interval Helpers\n * @summary Return the array of dates within the specified time interval.\n *\n * @description\n * Return the array of dates within the specified time interval.\n *\n * ### v2.0.0 breaking changes:\n *\n * - [Changes that are common for the whole library](https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#Common-Changes).\n *\n * - The function was renamed from `eachDay` to `eachDayOfInterval`.\n *   This change was made to mirror the use of the word \"interval\" in standard ISO 8601:2004 terminology:\n *\n *   ```\n *   2.1.3\n *   time interval\n *   part of the time axis limited by two instants\n *   ```\n *\n *   Also, this function now accepts an object with `start` and `end` properties\n *   instead of two arguments as an interval.\n *   This function now throws `RangeError` if the start of the interval is after its end\n *   or if any date in the interval is `Invalid Date`.\n *\n *   ```javascript\n *   // Before v2.0.0\n *\n *   eachDay(new Date(2014, 0, 10), new Date(2014, 0, 20))\n *\n *   // v2.0.0 onward\n *\n *   eachDayOfInterval(\n *     { start: new Date(2014, 0, 10), end: new Date(2014, 0, 20) }\n *   )\n *   ```\n *\n * @param {Interval} interval - the interval. See [Interval]{@link https://date-fns.org/docs/Interval}\n * @param {Object} [options] - an object with options.\n * @param {Number} [options.step=1] - the step to increment by. The value should be more than 1.\n * @returns {Date[]} the array with starts of days from the day of the interval start to the day of the interval end\n * @throws {TypeError} 1 argument required\n * @throws {RangeError} `options.step` must be a number greater than 1\n * @throws {RangeError} The start of an interval cannot be after its end\n * @throws {RangeError} Date in interval cannot be `Invalid Date`\n *\n * @example\n * // Each day between 6 October 2014 and 10 October 2014:\n * const result = eachDayOfInterval({\n *   start: new Date(2014, 9, 6),\n *   end: new Date(2014, 9, 10)\n * })\n * //=> [\n * //   Mon Oct 06 2014 00:00:00,\n * //   Tue Oct 07 2014 00:00:00,\n * //   Wed Oct 08 2014 00:00:00,\n * //   Thu Oct 09 2014 00:00:00,\n * //   Fri Oct 10 2014 00:00:00\n * // ]\n */\n\nexport default function eachDayOfInterval(dirtyInterval, options) {\n  requiredArgs(1, arguments);\n  var interval = dirtyInterval || {};\n  var startDate = toDate(interval.start);\n  var endDate = toDate(interval.end);\n  var endTime = endDate.getTime(); // Throw an exception if start date is after end date or if any date is `Invalid Date`\n\n  if (!(startDate.getTime() <= endTime)) {\n    throw new RangeError('Invalid interval');\n  }\n\n  var dates = [];\n  var currentDate = startDate;\n  currentDate.setHours(0, 0, 0, 0);\n  var step = options && 'step' in options ? Number(options.step) : 1;\n  if (step < 1 || isNaN(step)) throw new RangeError('`options.step` must be a number greater than 1');\n\n  while (currentDate.getTime() <= endTime) {\n    dates.push(toDate(currentDate));\n    currentDate.setDate(currentDate.getDate() + step);\n    currentDate.setHours(0, 0, 0, 0);\n  }\n\n  return dates;\n}","import toDate from \"../toDate/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\n/**\n * @name isSameMonth\n * @category Month Helpers\n * @summary Are the given dates in the same month (and year)?\n *\n * @description\n * Are the given dates in the same month (and year)?\n *\n * ### v2.0.0 breaking changes:\n *\n * - [Changes that are common for the whole library](https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#Common-Changes).\n *\n * @param {Date|Number} dateLeft - the first date to check\n * @param {Date|Number} dateRight - the second date to check\n * @returns {Boolean} the dates are in the same month (and year)\n * @throws {TypeError} 2 arguments required\n *\n * @example\n * // Are 2 September 2014 and 25 September 2014 in the same month?\n * var result = isSameMonth(new Date(2014, 8, 2), new Date(2014, 8, 25))\n * //=> true\n *\n * @example\n * // Are 2 September 2014 and 25 September 2015 in the same month?\n * var result = isSameMonth(new Date(2014, 8, 2), new Date(2015, 8, 25))\n * //=> false\n */\n\nexport default function isSameMonth(dirtyDateLeft, dirtyDateRight) {\n  requiredArgs(2, arguments);\n  var dateLeft = toDate(dirtyDateLeft);\n  var dateRight = toDate(dirtyDateRight);\n  return dateLeft.getFullYear() === dateRight.getFullYear() && dateLeft.getMonth() === dateRight.getMonth();\n}","import startOfWeek from \"../startOfWeek/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\n\n/**\n * @name isSameWeek\n * @category Week Helpers\n * @summary Are the given dates in the same week (and month and year)?\n *\n * @description\n * Are the given dates in the same week (and month and year)?\n *\n * ### v2.0.0 breaking changes:\n *\n * - [Changes that are common for the whole library](https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#Common-Changes).\n *\n * @param {Date|Number} dateLeft - the first date to check\n * @param {Date|Number} dateRight - the second date to check\n * @param {Object} [options] - an object with options.\n * @param {Locale} [options.locale=defaultLocale] - the locale object. See [Locale]{@link https://date-fns.org/docs/Locale}\n * @param {0|1|2|3|4|5|6} [options.weekStartsOn=0] - the index of the first day of the week (0 - Sunday)\n * @returns {Boolean} the dates are in the same week (and month and year)\n * @throws {TypeError} 2 arguments required\n * @throws {RangeError} `options.weekStartsOn` must be between 0 and 6\n *\n * @example\n * // Are 31 August 2014 and 4 September 2014 in the same week?\n * var result = isSameWeek(new Date(2014, 7, 31), new Date(2014, 8, 4))\n * //=> true\n *\n * @example\n * // If week starts with Monday,\n * // are 31 August 2014 and 4 September 2014 in the same week?\n * var result = isSameWeek(new Date(2014, 7, 31), new Date(2014, 8, 4), {\n *   weekStartsOn: 1\n * })\n * //=> false\n * \n * @example\n * // Are 1 January 2014 and 1 January 2015 in the same week?\n * var result = isSameWeek(new Date(2014, 0, 1), new Date(2015, 0, 1))\n * //=> false\n */\nexport default function isSameWeek(dirtyDateLeft, dirtyDateRight, dirtyOptions) {\n  requiredArgs(2, arguments);\n  var dateLeftStartOfWeek = startOfWeek(dirtyDateLeft, dirtyOptions);\n  var dateRightStartOfWeek = startOfWeek(dirtyDateRight, dirtyOptions);\n  return dateLeftStartOfWeek.getTime() === dateRightStartOfWeek.getTime();\n}","import toDate from \"../toDate/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\n/**\n * @name isWeekend\n * @category Weekday Helpers\n * @summary Does the given date fall on a weekend?\n *\n * @description\n * Does the given date fall on a weekend?\n *\n * ### v2.0.0 breaking changes:\n *\n * - [Changes that are common for the whole library](https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#Common-Changes).\n *\n * @param {Date|Number} date - the date to check\n * @returns {Boolean} the date falls on a weekend\n * @throws {TypeError} 1 argument required\n *\n * @example\n * // Does 5 October 2014 fall on a weekend?\n * const result = isWeekend(new Date(2014, 9, 5))\n * //=> true\n */\n\nexport default function isWeekend(dirtyDate) {\n  requiredArgs(1, arguments);\n  var date = toDate(dirtyDate);\n  var day = date.getDay();\n  return day === 0 || day === 6;\n}","import toDate from \"../toDate/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\n\n/**\n * @name isWithinInterval\n * @category Interval Helpers\n * @summary Is the given date within the interval?\n *\n * @description\n * Is the given date within the interval? (Including start and end.)\n *\n * ### v2.0.0 breaking changes:\n *\n * - [Changes that are common for the whole library](https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#Common-Changes).\n *\n * - The function was renamed from `isWithinRange` to `isWithinInterval`.\n *   This change was made to mirror the use of the word \"interval\" in standard ISO 8601:2004 terminology:\n *\n *   ```\n *   2.1.3\n *   time interval\n *   part of the time axis limited by two instants\n *   ```\n *\n *   Also, this function now accepts an object with `start` and `end` properties\n *   instead of two arguments as an interval.\n *   This function now throws `RangeError` if the start of the interval is after its end\n *   or if any date in the interval is `Invalid Date`.\n *\n *   ```javascript\n *   // Before v2.0.0\n *\n *   isWithinRange(\n *     new Date(2014, 0, 3),\n *     new Date(2014, 0, 1), new Date(2014, 0, 7)\n *   )\n *\n *   // v2.0.0 onward\n *\n *   isWithinInterval(\n *     new Date(2014, 0, 3),\n *     { start: new Date(2014, 0, 1), end: new Date(2014, 0, 7) }\n *   )\n *   ```\n *\n * @param {Date|Number} date - the date to check\n * @param {Interval} interval - the interval to check\n * @returns {Boolean} the date is within the interval\n * @throws {TypeError} 2 arguments required\n * @throws {RangeError} The start of an interval cannot be after its end\n * @throws {RangeError} Date in interval cannot be `Invalid Date`\n *\n * @example\n * // For the date within the interval:\n * isWithinInterval(new Date(2014, 0, 3), {\n *   start: new Date(2014, 0, 1),\n *   end: new Date(2014, 0, 7)\n * })\n * //=> true\n *\n * @example\n * // For the date outside of the interval:\n * isWithinInterval(new Date(2014, 0, 10), {\n *   start: new Date(2014, 0, 1),\n *   end: new Date(2014, 0, 7)\n * })\n * //=> false\n *\n * @example\n * // For date equal to interval start:\n * isWithinInterval(date, { start, end: date }) // => true\n *\n * @example\n * // For date equal to interval end:\n * isWithinInterval(date, { start: date, end }) // => true\n */\nexport default function isWithinInterval(dirtyDate, interval) {\n  requiredArgs(2, arguments);\n  var time = toDate(dirtyDate).getTime();\n  var startTime = toDate(interval.start).getTime();\n  var endTime = toDate(interval.end).getTime(); // Throw an exception if start date is after end date or if any date is `Invalid Date`\n\n  if (!(startTime <= endTime)) {\n    throw new RangeError('Invalid interval');\n  }\n\n  return time >= startTime && time <= endTime;\n}","import toDate from \"../toDate/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\n/**\n * @name lastDayOfMonth\n * @category Month Helpers\n * @summary Return the last day of a month for the given date.\n *\n * @description\n * Return the last day of a month for the given date.\n * The result will be in the local timezone.\n *\n * ### v2.0.0 breaking changes:\n *\n * - [Changes that are common for the whole library](https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#Common-Changes).\n *\n * @param {Date|Number} date - the original date\n * @returns {Date} the last day of a month\n * @throws {TypeError} 1 argument required\n *\n * @example\n * // The last day of a month for 2 September 2014 11:55:00:\n * var result = lastDayOfMonth(new Date(2014, 8, 2, 11, 55, 0))\n * //=> Tue Sep 30 2014 00:00:00\n */\n\nexport default function lastDayOfMonth(dirtyDate) {\n  requiredArgs(1, arguments);\n  var date = toDate(dirtyDate);\n  var month = date.getMonth();\n  date.setFullYear(date.getFullYear(), month + 1, 0);\n  date.setHours(0, 0, 0, 0);\n  return date;\n}","import toDate from \"../toDate/index.js\";\nimport toInteger from \"../_lib/toInteger/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\n\n/**\n * @name lastDayOfWeek\n * @category Week Helpers\n * @summary Return the last day of a week for the given date.\n *\n * @description\n * Return the last day of a week for the given date.\n * The result will be in the local timezone.\n *\n * ### v2.0.0 breaking changes:\n *\n * - [Changes that are common for the whole library](https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#Common-Changes).\n *\n * @param {Date|Number} date - the original date\n * @param {Object} [options] - an object with options.\n * @param {Locale} [options.locale=defaultLocale] - the locale object. See [Locale]{@link https://date-fns.org/docs/Locale}\n * @param {0|1|2|3|4|5|6} [options.weekStartsOn=0] - the index of the first day of the week (0 - Sunday)\n * @returns {Date} the last day of a week\n * @throws {TypeError} 1 argument required\n * @throws {RangeError} `options.weekStartsOn` must be between 0 and 6\n *\n * @example\n * // The last day of a week for 2 September 2014 11:55:00:\n * var result = lastDayOfWeek(new Date(2014, 8, 2, 11, 55, 0))\n * //=> Sat Sep 06 2014 00:00:00\n *\n * @example\n * // If the week starts on Monday, the last day of the week for 2 September 2014 11:55:00:\n * var result = lastDayOfWeek(new Date(2014, 8, 2, 11, 55, 0), { weekStartsOn: 1 })\n * //=> Sun Sep 07 2014 00:00:00\n */\nexport default function lastDayOfWeek(dirtyDate, dirtyOptions) {\n  requiredArgs(1, arguments);\n  var options = dirtyOptions || {};\n  var locale = options.locale;\n  var localeWeekStartsOn = locale && locale.options && locale.options.weekStartsOn;\n  var defaultWeekStartsOn = localeWeekStartsOn == null ? 0 : toInteger(localeWeekStartsOn);\n  var weekStartsOn = options.weekStartsOn == null ? defaultWeekStartsOn : toInteger(options.weekStartsOn); // Test if weekStartsOn is between 0 and 6 _and_ is not NaN\n\n  if (!(weekStartsOn >= 0 && weekStartsOn <= 6)) {\n    throw new RangeError('weekStartsOn must be between 0 and 6');\n  }\n\n  var date = toDate(dirtyDate);\n  var day = date.getDay();\n  var diff = (day < weekStartsOn ? -7 : 0) + 6 - (day - weekStartsOn);\n  date.setHours(0, 0, 0, 0);\n  date.setDate(date.getDate() + diff);\n  return date;\n}","import toInteger from \"../_lib/toInteger/index.js\";\nimport toDate from \"../toDate/index.js\";\nimport getDaysInMonth from \"../getDaysInMonth/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\n/**\n * @name setMonth\n * @category Month Helpers\n * @summary Set the month to the given date.\n *\n * @description\n * Set the month to the given date.\n *\n * ### v2.0.0 breaking changes:\n *\n * - [Changes that are common for the whole library](https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#Common-Changes).\n *\n * @param {Date|Number} date - the date to be changed\n * @param {Number} month - the month of the new date\n * @returns {Date} the new date with the month set\n * @throws {TypeError} 2 arguments required\n *\n * @example\n * // Set February to 1 September 2014:\n * const result = setMonth(new Date(2014, 8, 1), 1)\n * //=> Sat Feb 01 2014 00:00:00\n */\n\nexport default function setMonth(dirtyDate, dirtyMonth) {\n  requiredArgs(2, arguments);\n  var date = toDate(dirtyDate);\n  var month = toInteger(dirtyMonth);\n  var year = date.getFullYear();\n  var day = date.getDate();\n  var dateWithDesiredMonth = new Date(0);\n  dateWithDesiredMonth.setFullYear(year, month, 15);\n  dateWithDesiredMonth.setHours(0, 0, 0, 0);\n  var daysInMonth = getDaysInMonth(dateWithDesiredMonth); // Set the last day of the new month\n  // if the original date was the last day of the longer month\n\n  date.setMonth(month, Math.min(day, daysInMonth));\n  return date;\n}","import toDate from \"../toDate/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\n/**\n * @name getDaysInMonth\n * @category Month Helpers\n * @summary Get the number of days in a month of the given date.\n *\n * @description\n * Get the number of days in a month of the given date.\n *\n * ### v2.0.0 breaking changes:\n *\n * - [Changes that are common for the whole library](https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#Common-Changes).\n *\n * @param {Date|Number} date - the given date\n * @returns {Number} the number of days in a month\n * @throws {TypeError} 1 argument required\n *\n * @example\n * // How many days are in February 2000?\n * const result = getDaysInMonth(new Date(2000, 1))\n * //=> 29\n */\n\nexport default function getDaysInMonth(dirtyDate) {\n  requiredArgs(1, arguments);\n  var date = toDate(dirtyDate);\n  var year = date.getFullYear();\n  var monthIndex = date.getMonth();\n  var lastDayOfMonth = new Date(0);\n  lastDayOfMonth.setFullYear(year, monthIndex + 1, 0);\n  lastDayOfMonth.setHours(0, 0, 0, 0);\n  return lastDayOfMonth.getDate();\n}","import toDate from \"../toDate/index.js\";\nimport setMonth from \"../setMonth/index.js\";\nimport toInteger from \"../_lib/toInteger/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\n\n/**\n * @name set\n * @category Common Helpers\n * @summary Set date values to a given date.\n *\n * @description\n * Set date values to a given date.\n *\n * Sets time values to date from object `values`.\n * A value is not set if it is undefined or null or doesn't exist in `values`.\n *\n * Note about bundle size: `set` does not internally use `setX` functions from date-fns but instead opts\n * to use native `Date#setX` methods. If you use this function, you may not want to include the\n * other `setX` functions that date-fns provides if you are concerned about the bundle size.\n *\n * @param {Date|Number} date - the date to be changed\n * @param {Object} values - an object with options\n * @param {Number} [values.year] - the number of years to be set\n * @param {Number} [values.month] - the number of months to be set\n * @param {Number} [values.date] - the number of days to be set\n * @param {Number} [values.hours] - the number of hours to be set\n * @param {Number} [values.minutes] - the number of minutes to be set\n * @param {Number} [values.seconds] - the number of seconds to be set\n * @param {Number} [values.milliseconds] - the number of milliseconds to be set\n * @returns {Date} the new date with options set\n * @throws {TypeError} 2 arguments required\n * @throws {RangeError} `values` must be an object\n *\n * @example\n * // Transform 1 September 2014 into 20 October 2015 in a single line:\n * var result = set(new Date(2014, 8, 20), { year: 2015, month: 9, date: 20 })\n * //=> Tue Oct 20 2015 00:00:00\n *\n * @example\n * // Set 12 PM to 1 September 2014 01:23:45 to 1 September 2014 12:00:00:\n * var result = set(new Date(2014, 8, 1, 1, 23, 45), { hours: 12 })\n * //=> Mon Sep 01 2014 12:23:45\n */\nexport default function set(dirtyDate, values) {\n  requiredArgs(2, arguments);\n\n  if (typeof values !== 'object' || values === null) {\n    throw new RangeError('values parameter must be an object');\n  }\n\n  var date = toDate(dirtyDate); // Check if date is Invalid Date because Date.prototype.setFullYear ignores the value of Invalid Date\n\n  if (isNaN(date.getTime())) {\n    return new Date(NaN);\n  }\n\n  if (values.year != null) {\n    date.setFullYear(values.year);\n  }\n\n  if (values.month != null) {\n    date = setMonth(date, values.month);\n  }\n\n  if (values.date != null) {\n    date.setDate(toInteger(values.date));\n  }\n\n  if (values.hours != null) {\n    date.setHours(toInteger(values.hours));\n  }\n\n  if (values.minutes != null) {\n    date.setMinutes(toInteger(values.minutes));\n  }\n\n  if (values.seconds != null) {\n    date.setSeconds(toInteger(values.seconds));\n  }\n\n  if (values.milliseconds != null) {\n    date.setMilliseconds(toInteger(values.milliseconds));\n  }\n\n  return date;\n}","import toDate from \"../toDate/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\n/**\n * @name startOfMonth\n * @category Month Helpers\n * @summary Return the start of a month for the given date.\n *\n * @description\n * Return the start of a month for the given date.\n * The result will be in the local timezone.\n *\n * ### v2.0.0 breaking changes:\n *\n * - [Changes that are common for the whole library](https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#Common-Changes).\n *\n * @param {Date|Number} date - the original date\n * @returns {Date} the start of a month\n * @throws {TypeError} 1 argument required\n *\n * @example\n * // The start of a month for 2 September 2014 11:55:00:\n * const result = startOfMonth(new Date(2014, 8, 2, 11, 55, 0))\n * //=> Mon Sep 01 2014 00:00:00\n */\n\nexport default function startOfMonth(dirtyDate) {\n  requiredArgs(1, arguments);\n  var date = toDate(dirtyDate);\n  date.setDate(1);\n  date.setHours(0, 0, 0, 0);\n  return date;\n}","import toDate from \"../toDate/index.js\";\nimport toInteger from \"../_lib/toInteger/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\n/**\n * @name startOfWeek\n * @category Week Helpers\n * @summary Return the start of a week for the given date.\n *\n * @description\n * Return the start of a week for the given date.\n * The result will be in the local timezone.\n *\n * ### v2.0.0 breaking changes:\n *\n * - [Changes that are common for the whole library](https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#Common-Changes).\n *\n * @param {Date|Number} date - the original date\n * @param {Object} [options] - an object with options.\n * @param {Locale} [options.locale=defaultLocale] - the locale object. See [Locale]{@link https://date-fns.org/docs/Locale}\n * @param {0|1|2|3|4|5|6} [options.weekStartsOn=0] - the index of the first day of the week (0 - Sunday)\n * @returns {Date} the start of a week\n * @throws {TypeError} 1 argument required\n * @throws {RangeError} `options.weekStartsOn` must be between 0 and 6\n *\n * @example\n * // The start of a week for 2 September 2014 11:55:00:\n * const result = startOfWeek(new Date(2014, 8, 2, 11, 55, 0))\n * //=> Sun Aug 31 2014 00:00:00\n *\n * @example\n * // If the week starts on Monday, the start of the week for 2 September 2014 11:55:00:\n * const result = startOfWeek(new Date(2014, 8, 2, 11, 55, 0), { weekStartsOn: 1 })\n * //=> Mon Sep 01 2014 00:00:00\n */\n\nexport default function startOfWeek(dirtyDate, dirtyOptions) {\n  requiredArgs(1, arguments);\n  var options = dirtyOptions || {};\n  var locale = options.locale;\n  var localeWeekStartsOn = locale && locale.options && locale.options.weekStartsOn;\n  var defaultWeekStartsOn = localeWeekStartsOn == null ? 0 : toInteger(localeWeekStartsOn);\n  var weekStartsOn = options.weekStartsOn == null ? defaultWeekStartsOn : toInteger(options.weekStartsOn); // Test if weekStartsOn is between 0 and 6 _and_ is not NaN\n\n  if (!(weekStartsOn >= 0 && weekStartsOn <= 6)) {\n    throw new RangeError('weekStartsOn must be between 0 and 6 inclusively');\n  }\n\n  var date = toDate(dirtyDate);\n  var day = date.getDay();\n  var diff = (day < weekStartsOn ? 7 : 0) + day - weekStartsOn;\n  date.setDate(date.getDate() - diff);\n  date.setHours(0, 0, 0, 0);\n  return date;\n}","import toDate from \"../toDate/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\n/**\n * @name startOfYear\n * @category Year Helpers\n * @summary Return the start of a year for the given date.\n *\n * @description\n * Return the start of a year for the given date.\n * The result will be in the local timezone.\n *\n * ### v2.0.0 breaking changes:\n *\n * - [Changes that are common for the whole library](https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#Common-Changes).\n *\n * @param {Date|Number} date - the original date\n * @returns {Date} the start of a year\n * @throws {TypeError} 1 argument required\n *\n * @example\n * // The start of a year for 2 September 2014 11:55:00:\n * const result = startOfYear(new Date(2014, 8, 2, 11, 55, 00))\n * //=> Wed Jan 01 2014 00:00:00\n */\n\nexport default function startOfYear(dirtyDate) {\n  requiredArgs(1, arguments);\n  var cleanDate = toDate(dirtyDate);\n  var date = new Date(0);\n  date.setFullYear(cleanDate.getFullYear(), 0, 1);\n  date.setHours(0, 0, 0, 0);\n  return date;\n}","import toInteger from \"../_lib/toInteger/index.js\";\nimport addYears from \"../addYears/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\n/**\n * @name subYears\n * @category Year Helpers\n * @summary Subtract the specified number of years from the given date.\n *\n * @description\n * Subtract the specified number of years from the given date.\n *\n * ### v2.0.0 breaking changes:\n *\n * - [Changes that are common for the whole library](https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#Common-Changes).\n *\n * @param {Date|Number} date - the date to be changed\n * @param {Number} amount - the amount of years to be subtracted. Positive decimals will be rounded using `Math.floor`, decimals less than zero will be rounded using `Math.ceil`.\n * @returns {Date} the new date with the years subtracted\n * @throws {TypeError} 2 arguments required\n *\n * @example\n * // Subtract 5 years from 1 September 2014:\n * const result = subYears(new Date(2014, 8, 1), 5)\n * //=> Tue Sep 01 2009 00:00:00\n */\n\nexport default function subYears(dirtyDate, dirtyAmount) {\n  requiredArgs(2, arguments);\n  var amount = toInteger(dirtyAmount);\n  return addYears(dirtyDate, -amount);\n}","import toInteger from \"../_lib/toInteger/index.js\";\nimport addMonths from \"../addMonths/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\n/**\n * @name addYears\n * @category Year Helpers\n * @summary Add the specified number of years to the given date.\n *\n * @description\n * Add the specified number of years to the given date.\n *\n * ### v2.0.0 breaking changes:\n *\n * - [Changes that are common for the whole library](https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#Common-Changes).\n *\n * @param {Date|Number} date - the date to be changed\n * @param {Number} amount - the amount of years to be added. Positive decimals will be rounded using `Math.floor`, decimals less than zero will be rounded using `Math.ceil`.\n * @returns {Date} the new date with the years added\n * @throws {TypeError} 2 arguments required\n *\n * @example\n * // Add 5 years to 1 September 2014:\n * const result = addYears(new Date(2014, 8, 1), 5)\n * //=> Sun Sep 01 2019 00:00:00\n */\n\nexport default function addYears(dirtyDate, dirtyAmount) {\n  requiredArgs(2, arguments);\n  var amount = toInteger(dirtyAmount);\n  return addMonths(dirtyDate, amount * 12);\n}","'use strict';\nvar token = '%[a-f0-9]{2}';\nvar singleMatcher = new RegExp('(' + token + ')|([^%]+?)', 'gi');\nvar multiMatcher = new RegExp('(' + token + ')+', 'gi');\n\nfunction decodeComponents(components, split) {\n\ttry {\n\t\t// Try to decode the entire string first\n\t\treturn [decodeURIComponent(components.join(''))];\n\t} catch (err) {\n\t\t// Do nothing\n\t}\n\n\tif (components.length === 1) {\n\t\treturn components;\n\t}\n\n\tsplit = split || 1;\n\n\t// Split the array in 2 parts\n\tvar left = components.slice(0, split);\n\tvar right = components.slice(split);\n\n\treturn Array.prototype.concat.call([], decodeComponents(left), decodeComponents(right));\n}\n\nfunction decode(input) {\n\ttry {\n\t\treturn decodeURIComponent(input);\n\t} catch (err) {\n\t\tvar tokens = input.match(singleMatcher) || [];\n\n\t\tfor (var i = 1; i < tokens.length; i++) {\n\t\t\tinput = decodeComponents(tokens, i).join('');\n\n\t\t\ttokens = input.match(singleMatcher) || [];\n\t\t}\n\n\t\treturn input;\n\t}\n}\n\nfunction customDecodeURIComponent(input) {\n\t// Keep track of all the replacements and prefill the map with the `BOM`\n\tvar replaceMap = {\n\t\t'%FE%FF': '\\uFFFD\\uFFFD',\n\t\t'%FF%FE': '\\uFFFD\\uFFFD'\n\t};\n\n\tvar match = multiMatcher.exec(input);\n\twhile (match) {\n\t\ttry {\n\t\t\t// Decode as big chunks as possible\n\t\t\treplaceMap[match[0]] = decodeURIComponent(match[0]);\n\t\t} catch (err) {\n\t\t\tvar result = decode(match[0]);\n\n\t\t\tif (result !== match[0]) {\n\t\t\t\treplaceMap[match[0]] = result;\n\t\t\t}\n\t\t}\n\n\t\tmatch = multiMatcher.exec(input);\n\t}\n\n\t// Add `%C2` at the end of the map to make sure it does not replace the combinator before everything else\n\treplaceMap['%C2'] = '\\uFFFD';\n\n\tvar entries = Object.keys(replaceMap);\n\n\tfor (var i = 0; i < entries.length; i++) {\n\t\t// Replace all decoded components\n\t\tvar key = entries[i];\n\t\tinput = input.replace(new RegExp(key, 'g'), replaceMap[key]);\n\t}\n\n\treturn input;\n}\n\nmodule.exports = function (encodedURI) {\n\tif (typeof encodedURI !== 'string') {\n\t\tthrow new TypeError('Expected `encodedURI` to be of type `string`, got `' + typeof encodedURI + '`');\n\t}\n\n\ttry {\n\t\tencodedURI = encodedURI.replace(/\\+/g, ' ');\n\n\t\t// Try the built in decoder first\n\t\treturn decodeURIComponent(encodedURI);\n\t} catch (err) {\n\t\t// Fallback to a more advanced decoder\n\t\treturn customDecodeURIComponent(encodedURI);\n\t}\n};\n","'use strict';\nmodule.exports = function (obj, predicate) {\n\tvar ret = {};\n\tvar keys = Object.keys(obj);\n\tvar isArr = Array.isArray(predicate);\n\n\tfor (var i = 0; i < keys.length; i++) {\n\t\tvar key = keys[i];\n\t\tvar val = obj[key];\n\n\t\tif (isArr ? predicate.indexOf(key) !== -1 : predicate(key, val, obj)) {\n\t\t\tret[key] = val;\n\t\t}\n\t}\n\n\treturn ret;\n};\n","/*! Hammer.JS - v2.0.7 - 2016-04-22\n * http://hammerjs.github.io/\n *\n * Copyright (c) 2016 Jorik Tangelder;\n * Licensed under the MIT license */\n(function(window, document, exportName, undefined) {\n  'use strict';\n\nvar VENDOR_PREFIXES = ['', 'webkit', 'Moz', 'MS', 'ms', 'o'];\nvar TEST_ELEMENT = document.createElement('div');\n\nvar TYPE_FUNCTION = 'function';\n\nvar round = Math.round;\nvar abs = Math.abs;\nvar now = Date.now;\n\n/**\n * set a timeout with a given scope\n * @param {Function} fn\n * @param {Number} timeout\n * @param {Object} context\n * @returns {number}\n */\nfunction setTimeoutContext(fn, timeout, context) {\n    return setTimeout(bindFn(fn, context), timeout);\n}\n\n/**\n * if the argument is an array, we want to execute the fn on each entry\n * if it aint an array we don't want to do a thing.\n * this is used by all the methods that accept a single and array argument.\n * @param {*|Array} arg\n * @param {String} fn\n * @param {Object} [context]\n * @returns {Boolean}\n */\nfunction invokeArrayArg(arg, fn, context) {\n    if (Array.isArray(arg)) {\n        each(arg, context[fn], context);\n        return true;\n    }\n    return false;\n}\n\n/**\n * walk objects and arrays\n * @param {Object} obj\n * @param {Function} iterator\n * @param {Object} context\n */\nfunction each(obj, iterator, context) {\n    var i;\n\n    if (!obj) {\n        return;\n    }\n\n    if (obj.forEach) {\n        obj.forEach(iterator, context);\n    } else if (obj.length !== undefined) {\n        i = 0;\n        while (i < obj.length) {\n            iterator.call(context, obj[i], i, obj);\n            i++;\n        }\n    } else {\n        for (i in obj) {\n            obj.hasOwnProperty(i) && iterator.call(context, obj[i], i, obj);\n        }\n    }\n}\n\n/**\n * wrap a method with a deprecation warning and stack trace\n * @param {Function} method\n * @param {String} name\n * @param {String} message\n * @returns {Function} A new function wrapping the supplied method.\n */\nfunction deprecate(method, name, message) {\n    var deprecationMessage = 'DEPRECATED METHOD: ' + name + '\\n' + message + ' AT \\n';\n    return function() {\n        var e = new Error('get-stack-trace');\n        var stack = e && e.stack ? e.stack.replace(/^[^\\(]+?[\\n$]/gm, '')\n            .replace(/^\\s+at\\s+/gm, '')\n            .replace(/^Object.<anonymous>\\s*\\(/gm, '{anonymous}()@') : 'Unknown Stack Trace';\n\n        var log = window.console && (window.console.warn || window.console.log);\n        if (log) {\n            log.call(window.console, deprecationMessage, stack);\n        }\n        return method.apply(this, arguments);\n    };\n}\n\n/**\n * extend object.\n * means that properties in dest will be overwritten by the ones in src.\n * @param {Object} target\n * @param {...Object} objects_to_assign\n * @returns {Object} target\n */\nvar assign;\nif (typeof Object.assign !== 'function') {\n    assign = function assign(target) {\n        if (target === undefined || target === null) {\n            throw new TypeError('Cannot convert undefined or null to object');\n        }\n\n        var output = Object(target);\n        for (var index = 1; index < arguments.length; index++) {\n            var source = arguments[index];\n            if (source !== undefined && source !== null) {\n                for (var nextKey in source) {\n                    if (source.hasOwnProperty(nextKey)) {\n                        output[nextKey] = source[nextKey];\n                    }\n                }\n            }\n        }\n        return output;\n    };\n} else {\n    assign = Object.assign;\n}\n\n/**\n * extend object.\n * means that properties in dest will be overwritten by the ones in src.\n * @param {Object} dest\n * @param {Object} src\n * @param {Boolean} [merge=false]\n * @returns {Object} dest\n */\nvar extend = deprecate(function extend(dest, src, merge) {\n    var keys = Object.keys(src);\n    var i = 0;\n    while (i < keys.length) {\n        if (!merge || (merge && dest[keys[i]] === undefined)) {\n            dest[keys[i]] = src[keys[i]];\n        }\n        i++;\n    }\n    return dest;\n}, 'extend', 'Use `assign`.');\n\n/**\n * merge the values from src in the dest.\n * means that properties that exist in dest will not be overwritten by src\n * @param {Object} dest\n * @param {Object} src\n * @returns {Object} dest\n */\nvar merge = deprecate(function merge(dest, src) {\n    return extend(dest, src, true);\n}, 'merge', 'Use `assign`.');\n\n/**\n * simple class inheritance\n * @param {Function} child\n * @param {Function} base\n * @param {Object} [properties]\n */\nfunction inherit(child, base, properties) {\n    var baseP = base.prototype,\n        childP;\n\n    childP = child.prototype = Object.create(baseP);\n    childP.constructor = child;\n    childP._super = baseP;\n\n    if (properties) {\n        assign(childP, properties);\n    }\n}\n\n/**\n * simple function bind\n * @param {Function} fn\n * @param {Object} context\n * @returns {Function}\n */\nfunction bindFn(fn, context) {\n    return function boundFn() {\n        return fn.apply(context, arguments);\n    };\n}\n\n/**\n * let a boolean value also be a function that must return a boolean\n * this first item in args will be used as the context\n * @param {Boolean|Function} val\n * @param {Array} [args]\n * @returns {Boolean}\n */\nfunction boolOrFn(val, args) {\n    if (typeof val == TYPE_FUNCTION) {\n        return val.apply(args ? args[0] || undefined : undefined, args);\n    }\n    return val;\n}\n\n/**\n * use the val2 when val1 is undefined\n * @param {*} val1\n * @param {*} val2\n * @returns {*}\n */\nfunction ifUndefined(val1, val2) {\n    return (val1 === undefined) ? val2 : val1;\n}\n\n/**\n * addEventListener with multiple events at once\n * @param {EventTarget} target\n * @param {String} types\n * @param {Function} handler\n */\nfunction addEventListeners(target, types, handler) {\n    each(splitStr(types), function(type) {\n        target.addEventListener(type, handler, false);\n    });\n}\n\n/**\n * removeEventListener with multiple events at once\n * @param {EventTarget} target\n * @param {String} types\n * @param {Function} handler\n */\nfunction removeEventListeners(target, types, handler) {\n    each(splitStr(types), function(type) {\n        target.removeEventListener(type, handler, false);\n    });\n}\n\n/**\n * find if a node is in the given parent\n * @method hasParent\n * @param {HTMLElement} node\n * @param {HTMLElement} parent\n * @return {Boolean} found\n */\nfunction hasParent(node, parent) {\n    while (node) {\n        if (node == parent) {\n            return true;\n        }\n        node = node.parentNode;\n    }\n    return false;\n}\n\n/**\n * small indexOf wrapper\n * @param {String} str\n * @param {String} find\n * @returns {Boolean} found\n */\nfunction inStr(str, find) {\n    return str.indexOf(find) > -1;\n}\n\n/**\n * split string on whitespace\n * @param {String} str\n * @returns {Array} words\n */\nfunction splitStr(str) {\n    return str.trim().split(/\\s+/g);\n}\n\n/**\n * find if a array contains the object using indexOf or a simple polyFill\n * @param {Array} src\n * @param {String} find\n * @param {String} [findByKey]\n * @return {Boolean|Number} false when not found, or the index\n */\nfunction inArray(src, find, findByKey) {\n    if (src.indexOf && !findByKey) {\n        return src.indexOf(find);\n    } else {\n        var i = 0;\n        while (i < src.length) {\n            if ((findByKey && src[i][findByKey] == find) || (!findByKey && src[i] === find)) {\n                return i;\n            }\n            i++;\n        }\n        return -1;\n    }\n}\n\n/**\n * convert array-like objects to real arrays\n * @param {Object} obj\n * @returns {Array}\n */\nfunction toArray(obj) {\n    return Array.prototype.slice.call(obj, 0);\n}\n\n/**\n * unique array with objects based on a key (like 'id') or just by the array's value\n * @param {Array} src [{id:1},{id:2},{id:1}]\n * @param {String} [key]\n * @param {Boolean} [sort=False]\n * @returns {Array} [{id:1},{id:2}]\n */\nfunction uniqueArray(src, key, sort) {\n    var results = [];\n    var values = [];\n    var i = 0;\n\n    while (i < src.length) {\n        var val = key ? src[i][key] : src[i];\n        if (inArray(values, val) < 0) {\n            results.push(src[i]);\n        }\n        values[i] = val;\n        i++;\n    }\n\n    if (sort) {\n        if (!key) {\n            results = results.sort();\n        } else {\n            results = results.sort(function sortUniqueArray(a, b) {\n                return a[key] > b[key];\n            });\n        }\n    }\n\n    return results;\n}\n\n/**\n * get the prefixed property\n * @param {Object} obj\n * @param {String} property\n * @returns {String|Undefined} prefixed\n */\nfunction prefixed(obj, property) {\n    var prefix, prop;\n    var camelProp = property[0].toUpperCase() + property.slice(1);\n\n    var i = 0;\n    while (i < VENDOR_PREFIXES.length) {\n        prefix = VENDOR_PREFIXES[i];\n        prop = (prefix) ? prefix + camelProp : property;\n\n        if (prop in obj) {\n            return prop;\n        }\n        i++;\n    }\n    return undefined;\n}\n\n/**\n * get a unique id\n * @returns {number} uniqueId\n */\nvar _uniqueId = 1;\nfunction uniqueId() {\n    return _uniqueId++;\n}\n\n/**\n * get the window object of an element\n * @param {HTMLElement} element\n * @returns {DocumentView|Window}\n */\nfunction getWindowForElement(element) {\n    var doc = element.ownerDocument || element;\n    return (doc.defaultView || doc.parentWindow || window);\n}\n\nvar MOBILE_REGEX = /mobile|tablet|ip(ad|hone|od)|android/i;\n\nvar SUPPORT_TOUCH = ('ontouchstart' in window);\nvar SUPPORT_POINTER_EVENTS = prefixed(window, 'PointerEvent') !== undefined;\nvar SUPPORT_ONLY_TOUCH = SUPPORT_TOUCH && MOBILE_REGEX.test(navigator.userAgent);\n\nvar INPUT_TYPE_TOUCH = 'touch';\nvar INPUT_TYPE_PEN = 'pen';\nvar INPUT_TYPE_MOUSE = 'mouse';\nvar INPUT_TYPE_KINECT = 'kinect';\n\nvar COMPUTE_INTERVAL = 25;\n\nvar INPUT_START = 1;\nvar INPUT_MOVE = 2;\nvar INPUT_END = 4;\nvar INPUT_CANCEL = 8;\n\nvar DIRECTION_NONE = 1;\nvar DIRECTION_LEFT = 2;\nvar DIRECTION_RIGHT = 4;\nvar DIRECTION_UP = 8;\nvar DIRECTION_DOWN = 16;\n\nvar DIRECTION_HORIZONTAL = DIRECTION_LEFT | DIRECTION_RIGHT;\nvar DIRECTION_VERTICAL = DIRECTION_UP | DIRECTION_DOWN;\nvar DIRECTION_ALL = DIRECTION_HORIZONTAL | DIRECTION_VERTICAL;\n\nvar PROPS_XY = ['x', 'y'];\nvar PROPS_CLIENT_XY = ['clientX', 'clientY'];\n\n/**\n * create new input type manager\n * @param {Manager} manager\n * @param {Function} callback\n * @returns {Input}\n * @constructor\n */\nfunction Input(manager, callback) {\n    var self = this;\n    this.manager = manager;\n    this.callback = callback;\n    this.element = manager.element;\n    this.target = manager.options.inputTarget;\n\n    // smaller wrapper around the handler, for the scope and the enabled state of the manager,\n    // so when disabled the input events are completely bypassed.\n    this.domHandler = function(ev) {\n        if (boolOrFn(manager.options.enable, [manager])) {\n            self.handler(ev);\n        }\n    };\n\n    this.init();\n\n}\n\nInput.prototype = {\n    /**\n     * should handle the inputEvent data and trigger the callback\n     * @virtual\n     */\n    handler: function() { },\n\n    /**\n     * bind the events\n     */\n    init: function() {\n        this.evEl && addEventListeners(this.element, this.evEl, this.domHandler);\n        this.evTarget && addEventListeners(this.target, this.evTarget, this.domHandler);\n        this.evWin && addEventListeners(getWindowForElement(this.element), this.evWin, this.domHandler);\n    },\n\n    /**\n     * unbind the events\n     */\n    destroy: function() {\n        this.evEl && removeEventListeners(this.element, this.evEl, this.domHandler);\n        this.evTarget && removeEventListeners(this.target, this.evTarget, this.domHandler);\n        this.evWin && removeEventListeners(getWindowForElement(this.element), this.evWin, this.domHandler);\n    }\n};\n\n/**\n * create new input type manager\n * called by the Manager constructor\n * @param {Hammer} manager\n * @returns {Input}\n */\nfunction createInputInstance(manager) {\n    var Type;\n    var inputClass = manager.options.inputClass;\n\n    if (inputClass) {\n        Type = inputClass;\n    } else if (SUPPORT_POINTER_EVENTS) {\n        Type = PointerEventInput;\n    } else if (SUPPORT_ONLY_TOUCH) {\n        Type = TouchInput;\n    } else if (!SUPPORT_TOUCH) {\n        Type = MouseInput;\n    } else {\n        Type = TouchMouseInput;\n    }\n    return new (Type)(manager, inputHandler);\n}\n\n/**\n * handle input events\n * @param {Manager} manager\n * @param {String} eventType\n * @param {Object} input\n */\nfunction inputHandler(manager, eventType, input) {\n    var pointersLen = input.pointers.length;\n    var changedPointersLen = input.changedPointers.length;\n    var isFirst = (eventType & INPUT_START && (pointersLen - changedPointersLen === 0));\n    var isFinal = (eventType & (INPUT_END | INPUT_CANCEL) && (pointersLen - changedPointersLen === 0));\n\n    input.isFirst = !!isFirst;\n    input.isFinal = !!isFinal;\n\n    if (isFirst) {\n        manager.session = {};\n    }\n\n    // source event is the normalized value of the domEvents\n    // like 'touchstart, mouseup, pointerdown'\n    input.eventType = eventType;\n\n    // compute scale, rotation etc\n    computeInputData(manager, input);\n\n    // emit secret event\n    manager.emit('hammer.input', input);\n\n    manager.recognize(input);\n    manager.session.prevInput = input;\n}\n\n/**\n * extend the data with some usable properties like scale, rotate, velocity etc\n * @param {Object} manager\n * @param {Object} input\n */\nfunction computeInputData(manager, input) {\n    var session = manager.session;\n    var pointers = input.pointers;\n    var pointersLength = pointers.length;\n\n    // store the first input to calculate the distance and direction\n    if (!session.firstInput) {\n        session.firstInput = simpleCloneInputData(input);\n    }\n\n    // to compute scale and rotation we need to store the multiple touches\n    if (pointersLength > 1 && !session.firstMultiple) {\n        session.firstMultiple = simpleCloneInputData(input);\n    } else if (pointersLength === 1) {\n        session.firstMultiple = false;\n    }\n\n    var firstInput = session.firstInput;\n    var firstMultiple = session.firstMultiple;\n    var offsetCenter = firstMultiple ? firstMultiple.center : firstInput.center;\n\n    var center = input.center = getCenter(pointers);\n    input.timeStamp = now();\n    input.deltaTime = input.timeStamp - firstInput.timeStamp;\n\n    input.angle = getAngle(offsetCenter, center);\n    input.distance = getDistance(offsetCenter, center);\n\n    computeDeltaXY(session, input);\n    input.offsetDirection = getDirection(input.deltaX, input.deltaY);\n\n    var overallVelocity = getVelocity(input.deltaTime, input.deltaX, input.deltaY);\n    input.overallVelocityX = overallVelocity.x;\n    input.overallVelocityY = overallVelocity.y;\n    input.overallVelocity = (abs(overallVelocity.x) > abs(overallVelocity.y)) ? overallVelocity.x : overallVelocity.y;\n\n    input.scale = firstMultiple ? getScale(firstMultiple.pointers, pointers) : 1;\n    input.rotation = firstMultiple ? getRotation(firstMultiple.pointers, pointers) : 0;\n\n    input.maxPointers = !session.prevInput ? input.pointers.length : ((input.pointers.length >\n        session.prevInput.maxPointers) ? input.pointers.length : session.prevInput.maxPointers);\n\n    computeIntervalInputData(session, input);\n\n    // find the correct target\n    var target = manager.element;\n    if (hasParent(input.srcEvent.target, target)) {\n        target = input.srcEvent.target;\n    }\n    input.target = target;\n}\n\nfunction computeDeltaXY(session, input) {\n    var center = input.center;\n    var offset = session.offsetDelta || {};\n    var prevDelta = session.prevDelta || {};\n    var prevInput = session.prevInput || {};\n\n    if (input.eventType === INPUT_START || prevInput.eventType === INPUT_END) {\n        prevDelta = session.prevDelta = {\n            x: prevInput.deltaX || 0,\n            y: prevInput.deltaY || 0\n        };\n\n        offset = session.offsetDelta = {\n            x: center.x,\n            y: center.y\n        };\n    }\n\n    input.deltaX = prevDelta.x + (center.x - offset.x);\n    input.deltaY = prevDelta.y + (center.y - offset.y);\n}\n\n/**\n * velocity is calculated every x ms\n * @param {Object} session\n * @param {Object} input\n */\nfunction computeIntervalInputData(session, input) {\n    var last = session.lastInterval || input,\n        deltaTime = input.timeStamp - last.timeStamp,\n        velocity, velocityX, velocityY, direction;\n\n    if (input.eventType != INPUT_CANCEL && (deltaTime > COMPUTE_INTERVAL || last.velocity === undefined)) {\n        var deltaX = input.deltaX - last.deltaX;\n        var deltaY = input.deltaY - last.deltaY;\n\n        var v = getVelocity(deltaTime, deltaX, deltaY);\n        velocityX = v.x;\n        velocityY = v.y;\n        velocity = (abs(v.x) > abs(v.y)) ? v.x : v.y;\n        direction = getDirection(deltaX, deltaY);\n\n        session.lastInterval = input;\n    } else {\n        // use latest velocity info if it doesn't overtake a minimum period\n        velocity = last.velocity;\n        velocityX = last.velocityX;\n        velocityY = last.velocityY;\n        direction = last.direction;\n    }\n\n    input.velocity = velocity;\n    input.velocityX = velocityX;\n    input.velocityY = velocityY;\n    input.direction = direction;\n}\n\n/**\n * create a simple clone from the input used for storage of firstInput and firstMultiple\n * @param {Object} input\n * @returns {Object} clonedInputData\n */\nfunction simpleCloneInputData(input) {\n    // make a simple copy of the pointers because we will get a reference if we don't\n    // we only need clientXY for the calculations\n    var pointers = [];\n    var i = 0;\n    while (i < input.pointers.length) {\n        pointers[i] = {\n            clientX: round(input.pointers[i].clientX),\n            clientY: round(input.pointers[i].clientY)\n        };\n        i++;\n    }\n\n    return {\n        timeStamp: now(),\n        pointers: pointers,\n        center: getCenter(pointers),\n        deltaX: input.deltaX,\n        deltaY: input.deltaY\n    };\n}\n\n/**\n * get the center of all the pointers\n * @param {Array} pointers\n * @return {Object} center contains `x` and `y` properties\n */\nfunction getCenter(pointers) {\n    var pointersLength = pointers.length;\n\n    // no need to loop when only one touch\n    if (pointersLength === 1) {\n        return {\n            x: round(pointers[0].clientX),\n            y: round(pointers[0].clientY)\n        };\n    }\n\n    var x = 0, y = 0, i = 0;\n    while (i < pointersLength) {\n        x += pointers[i].clientX;\n        y += pointers[i].clientY;\n        i++;\n    }\n\n    return {\n        x: round(x / pointersLength),\n        y: round(y / pointersLength)\n    };\n}\n\n/**\n * calculate the velocity between two points. unit is in px per ms.\n * @param {Number} deltaTime\n * @param {Number} x\n * @param {Number} y\n * @return {Object} velocity `x` and `y`\n */\nfunction getVelocity(deltaTime, x, y) {\n    return {\n        x: x / deltaTime || 0,\n        y: y / deltaTime || 0\n    };\n}\n\n/**\n * get the direction between two points\n * @param {Number} x\n * @param {Number} y\n * @return {Number} direction\n */\nfunction getDirection(x, y) {\n    if (x === y) {\n        return DIRECTION_NONE;\n    }\n\n    if (abs(x) >= abs(y)) {\n        return x < 0 ? DIRECTION_LEFT : DIRECTION_RIGHT;\n    }\n    return y < 0 ? DIRECTION_UP : DIRECTION_DOWN;\n}\n\n/**\n * calculate the absolute distance between two points\n * @param {Object} p1 {x, y}\n * @param {Object} p2 {x, y}\n * @param {Array} [props] containing x and y keys\n * @return {Number} distance\n */\nfunction getDistance(p1, p2, props) {\n    if (!props) {\n        props = PROPS_XY;\n    }\n    var x = p2[props[0]] - p1[props[0]],\n        y = p2[props[1]] - p1[props[1]];\n\n    return Math.sqrt((x * x) + (y * y));\n}\n\n/**\n * calculate the angle between two coordinates\n * @param {Object} p1\n * @param {Object} p2\n * @param {Array} [props] containing x and y keys\n * @return {Number} angle\n */\nfunction getAngle(p1, p2, props) {\n    if (!props) {\n        props = PROPS_XY;\n    }\n    var x = p2[props[0]] - p1[props[0]],\n        y = p2[props[1]] - p1[props[1]];\n    return Math.atan2(y, x) * 180 / Math.PI;\n}\n\n/**\n * calculate the rotation degrees between two pointersets\n * @param {Array} start array of pointers\n * @param {Array} end array of pointers\n * @return {Number} rotation\n */\nfunction getRotation(start, end) {\n    return getAngle(end[1], end[0], PROPS_CLIENT_XY) + getAngle(start[1], start[0], PROPS_CLIENT_XY);\n}\n\n/**\n * calculate the scale factor between two pointersets\n * no scale is 1, and goes down to 0 when pinched together, and bigger when pinched out\n * @param {Array} start array of pointers\n * @param {Array} end array of pointers\n * @return {Number} scale\n */\nfunction getScale(start, end) {\n    return getDistance(end[0], end[1], PROPS_CLIENT_XY) / getDistance(start[0], start[1], PROPS_CLIENT_XY);\n}\n\nvar MOUSE_INPUT_MAP = {\n    mousedown: INPUT_START,\n    mousemove: INPUT_MOVE,\n    mouseup: INPUT_END\n};\n\nvar MOUSE_ELEMENT_EVENTS = 'mousedown';\nvar MOUSE_WINDOW_EVENTS = 'mousemove mouseup';\n\n/**\n * Mouse events input\n * @constructor\n * @extends Input\n */\nfunction MouseInput() {\n    this.evEl = MOUSE_ELEMENT_EVENTS;\n    this.evWin = MOUSE_WINDOW_EVENTS;\n\n    this.pressed = false; // mousedown state\n\n    Input.apply(this, arguments);\n}\n\ninherit(MouseInput, Input, {\n    /**\n     * handle mouse events\n     * @param {Object} ev\n     */\n    handler: function MEhandler(ev) {\n        var eventType = MOUSE_INPUT_MAP[ev.type];\n\n        // on start we want to have the left mouse button down\n        if (eventType & INPUT_START && ev.button === 0) {\n            this.pressed = true;\n        }\n\n        if (eventType & INPUT_MOVE && ev.which !== 1) {\n            eventType = INPUT_END;\n        }\n\n        // mouse must be down\n        if (!this.pressed) {\n            return;\n        }\n\n        if (eventType & INPUT_END) {\n            this.pressed = false;\n        }\n\n        this.callback(this.manager, eventType, {\n            pointers: [ev],\n            changedPointers: [ev],\n            pointerType: INPUT_TYPE_MOUSE,\n            srcEvent: ev\n        });\n    }\n});\n\nvar POINTER_INPUT_MAP = {\n    pointerdown: INPUT_START,\n    pointermove: INPUT_MOVE,\n    pointerup: INPUT_END,\n    pointercancel: INPUT_CANCEL,\n    pointerout: INPUT_CANCEL\n};\n\n// in IE10 the pointer types is defined as an enum\nvar IE10_POINTER_TYPE_ENUM = {\n    2: INPUT_TYPE_TOUCH,\n    3: INPUT_TYPE_PEN,\n    4: INPUT_TYPE_MOUSE,\n    5: INPUT_TYPE_KINECT // see https://twitter.com/jacobrossi/status/480596438489890816\n};\n\nvar POINTER_ELEMENT_EVENTS = 'pointerdown';\nvar POINTER_WINDOW_EVENTS = 'pointermove pointerup pointercancel';\n\n// IE10 has prefixed support, and case-sensitive\nif (window.MSPointerEvent && !window.PointerEvent) {\n    POINTER_ELEMENT_EVENTS = 'MSPointerDown';\n    POINTER_WINDOW_EVENTS = 'MSPointerMove MSPointerUp MSPointerCancel';\n}\n\n/**\n * Pointer events input\n * @constructor\n * @extends Input\n */\nfunction PointerEventInput() {\n    this.evEl = POINTER_ELEMENT_EVENTS;\n    this.evWin = POINTER_WINDOW_EVENTS;\n\n    Input.apply(this, arguments);\n\n    this.store = (this.manager.session.pointerEvents = []);\n}\n\ninherit(PointerEventInput, Input, {\n    /**\n     * handle mouse events\n     * @param {Object} ev\n     */\n    handler: function PEhandler(ev) {\n        var store = this.store;\n        var removePointer = false;\n\n        var eventTypeNormalized = ev.type.toLowerCase().replace('ms', '');\n        var eventType = POINTER_INPUT_MAP[eventTypeNormalized];\n        var pointerType = IE10_POINTER_TYPE_ENUM[ev.pointerType] || ev.pointerType;\n\n        var isTouch = (pointerType == INPUT_TYPE_TOUCH);\n\n        // get index of the event in the store\n        var storeIndex = inArray(store, ev.pointerId, 'pointerId');\n\n        // start and mouse must be down\n        if (eventType & INPUT_START && (ev.button === 0 || isTouch)) {\n            if (storeIndex < 0) {\n                store.push(ev);\n                storeIndex = store.length - 1;\n            }\n        } else if (eventType & (INPUT_END | INPUT_CANCEL)) {\n            removePointer = true;\n        }\n\n        // it not found, so the pointer hasn't been down (so it's probably a hover)\n        if (storeIndex < 0) {\n            return;\n        }\n\n        // update the event in the store\n        store[storeIndex] = ev;\n\n        this.callback(this.manager, eventType, {\n            pointers: store,\n            changedPointers: [ev],\n            pointerType: pointerType,\n            srcEvent: ev\n        });\n\n        if (removePointer) {\n            // remove from the store\n            store.splice(storeIndex, 1);\n        }\n    }\n});\n\nvar SINGLE_TOUCH_INPUT_MAP = {\n    touchstart: INPUT_START,\n    touchmove: INPUT_MOVE,\n    touchend: INPUT_END,\n    touchcancel: INPUT_CANCEL\n};\n\nvar SINGLE_TOUCH_TARGET_EVENTS = 'touchstart';\nvar SINGLE_TOUCH_WINDOW_EVENTS = 'touchstart touchmove touchend touchcancel';\n\n/**\n * Touch events input\n * @constructor\n * @extends Input\n */\nfunction SingleTouchInput() {\n    this.evTarget = SINGLE_TOUCH_TARGET_EVENTS;\n    this.evWin = SINGLE_TOUCH_WINDOW_EVENTS;\n    this.started = false;\n\n    Input.apply(this, arguments);\n}\n\ninherit(SingleTouchInput, Input, {\n    handler: function TEhandler(ev) {\n        var type = SINGLE_TOUCH_INPUT_MAP[ev.type];\n\n        // should we handle the touch events?\n        if (type === INPUT_START) {\n            this.started = true;\n        }\n\n        if (!this.started) {\n            return;\n        }\n\n        var touches = normalizeSingleTouches.call(this, ev, type);\n\n        // when done, reset the started state\n        if (type & (INPUT_END | INPUT_CANCEL) && touches[0].length - touches[1].length === 0) {\n            this.started = false;\n        }\n\n        this.callback(this.manager, type, {\n            pointers: touches[0],\n            changedPointers: touches[1],\n            pointerType: INPUT_TYPE_TOUCH,\n            srcEvent: ev\n        });\n    }\n});\n\n/**\n * @this {TouchInput}\n * @param {Object} ev\n * @param {Number} type flag\n * @returns {undefined|Array} [all, changed]\n */\nfunction normalizeSingleTouches(ev, type) {\n    var all = toArray(ev.touches);\n    var changed = toArray(ev.changedTouches);\n\n    if (type & (INPUT_END | INPUT_CANCEL)) {\n        all = uniqueArray(all.concat(changed), 'identifier', true);\n    }\n\n    return [all, changed];\n}\n\nvar TOUCH_INPUT_MAP = {\n    touchstart: INPUT_START,\n    touchmove: INPUT_MOVE,\n    touchend: INPUT_END,\n    touchcancel: INPUT_CANCEL\n};\n\nvar TOUCH_TARGET_EVENTS = 'touchstart touchmove touchend touchcancel';\n\n/**\n * Multi-user touch events input\n * @constructor\n * @extends Input\n */\nfunction TouchInput() {\n    this.evTarget = TOUCH_TARGET_EVENTS;\n    this.targetIds = {};\n\n    Input.apply(this, arguments);\n}\n\ninherit(TouchInput, Input, {\n    handler: function MTEhandler(ev) {\n        var type = TOUCH_INPUT_MAP[ev.type];\n        var touches = getTouches.call(this, ev, type);\n        if (!touches) {\n            return;\n        }\n\n        this.callback(this.manager, type, {\n            pointers: touches[0],\n            changedPointers: touches[1],\n            pointerType: INPUT_TYPE_TOUCH,\n            srcEvent: ev\n        });\n    }\n});\n\n/**\n * @this {TouchInput}\n * @param {Object} ev\n * @param {Number} type flag\n * @returns {undefined|Array} [all, changed]\n */\nfunction getTouches(ev, type) {\n    var allTouches = toArray(ev.touches);\n    var targetIds = this.targetIds;\n\n    // when there is only one touch, the process can be simplified\n    if (type & (INPUT_START | INPUT_MOVE) && allTouches.length === 1) {\n        targetIds[allTouches[0].identifier] = true;\n        return [allTouches, allTouches];\n    }\n\n    var i,\n        targetTouches,\n        changedTouches = toArray(ev.changedTouches),\n        changedTargetTouches = [],\n        target = this.target;\n\n    // get target touches from touches\n    targetTouches = allTouches.filter(function(touch) {\n        return hasParent(touch.target, target);\n    });\n\n    // collect touches\n    if (type === INPUT_START) {\n        i = 0;\n        while (i < targetTouches.length) {\n            targetIds[targetTouches[i].identifier] = true;\n            i++;\n        }\n    }\n\n    // filter changed touches to only contain touches that exist in the collected target ids\n    i = 0;\n    while (i < changedTouches.length) {\n        if (targetIds[changedTouches[i].identifier]) {\n            changedTargetTouches.push(changedTouches[i]);\n        }\n\n        // cleanup removed touches\n        if (type & (INPUT_END | INPUT_CANCEL)) {\n            delete targetIds[changedTouches[i].identifier];\n        }\n        i++;\n    }\n\n    if (!changedTargetTouches.length) {\n        return;\n    }\n\n    return [\n        // merge targetTouches with changedTargetTouches so it contains ALL touches, including 'end' and 'cancel'\n        uniqueArray(targetTouches.concat(changedTargetTouches), 'identifier', true),\n        changedTargetTouches\n    ];\n}\n\n/**\n * Combined touch and mouse input\n *\n * Touch has a higher priority then mouse, and while touching no mouse events are allowed.\n * This because touch devices also emit mouse events while doing a touch.\n *\n * @constructor\n * @extends Input\n */\n\nvar DEDUP_TIMEOUT = 2500;\nvar DEDUP_DISTANCE = 25;\n\nfunction TouchMouseInput() {\n    Input.apply(this, arguments);\n\n    var handler = bindFn(this.handler, this);\n    this.touch = new TouchInput(this.manager, handler);\n    this.mouse = new MouseInput(this.manager, handler);\n\n    this.primaryTouch = null;\n    this.lastTouches = [];\n}\n\ninherit(TouchMouseInput, Input, {\n    /**\n     * handle mouse and touch events\n     * @param {Hammer} manager\n     * @param {String} inputEvent\n     * @param {Object} inputData\n     */\n    handler: function TMEhandler(manager, inputEvent, inputData) {\n        var isTouch = (inputData.pointerType == INPUT_TYPE_TOUCH),\n            isMouse = (inputData.pointerType == INPUT_TYPE_MOUSE);\n\n        if (isMouse && inputData.sourceCapabilities && inputData.sourceCapabilities.firesTouchEvents) {\n            return;\n        }\n\n        // when we're in a touch event, record touches to  de-dupe synthetic mouse event\n        if (isTouch) {\n            recordTouches.call(this, inputEvent, inputData);\n        } else if (isMouse && isSyntheticEvent.call(this, inputData)) {\n            return;\n        }\n\n        this.callback(manager, inputEvent, inputData);\n    },\n\n    /**\n     * remove the event listeners\n     */\n    destroy: function destroy() {\n        this.touch.destroy();\n        this.mouse.destroy();\n    }\n});\n\nfunction recordTouches(eventType, eventData) {\n    if (eventType & INPUT_START) {\n        this.primaryTouch = eventData.changedPointers[0].identifier;\n        setLastTouch.call(this, eventData);\n    } else if (eventType & (INPUT_END | INPUT_CANCEL)) {\n        setLastTouch.call(this, eventData);\n    }\n}\n\nfunction setLastTouch(eventData) {\n    var touch = eventData.changedPointers[0];\n\n    if (touch.identifier === this.primaryTouch) {\n        var lastTouch = {x: touch.clientX, y: touch.clientY};\n        this.lastTouches.push(lastTouch);\n        var lts = this.lastTouches;\n        var removeLastTouch = function() {\n            var i = lts.indexOf(lastTouch);\n            if (i > -1) {\n                lts.splice(i, 1);\n            }\n        };\n        setTimeout(removeLastTouch, DEDUP_TIMEOUT);\n    }\n}\n\nfunction isSyntheticEvent(eventData) {\n    var x = eventData.srcEvent.clientX, y = eventData.srcEvent.clientY;\n    for (var i = 0; i < this.lastTouches.length; i++) {\n        var t = this.lastTouches[i];\n        var dx = Math.abs(x - t.x), dy = Math.abs(y - t.y);\n        if (dx <= DEDUP_DISTANCE && dy <= DEDUP_DISTANCE) {\n            return true;\n        }\n    }\n    return false;\n}\n\nvar PREFIXED_TOUCH_ACTION = prefixed(TEST_ELEMENT.style, 'touchAction');\nvar NATIVE_TOUCH_ACTION = PREFIXED_TOUCH_ACTION !== undefined;\n\n// magical touchAction value\nvar TOUCH_ACTION_COMPUTE = 'compute';\nvar TOUCH_ACTION_AUTO = 'auto';\nvar TOUCH_ACTION_MANIPULATION = 'manipulation'; // not implemented\nvar TOUCH_ACTION_NONE = 'none';\nvar TOUCH_ACTION_PAN_X = 'pan-x';\nvar TOUCH_ACTION_PAN_Y = 'pan-y';\nvar TOUCH_ACTION_MAP = getTouchActionProps();\n\n/**\n * Touch Action\n * sets the touchAction property or uses the js alternative\n * @param {Manager} manager\n * @param {String} value\n * @constructor\n */\nfunction TouchAction(manager, value) {\n    this.manager = manager;\n    this.set(value);\n}\n\nTouchAction.prototype = {\n    /**\n     * set the touchAction value on the element or enable the polyfill\n     * @param {String} value\n     */\n    set: function(value) {\n        // find out the touch-action by the event handlers\n        if (value == TOUCH_ACTION_COMPUTE) {\n            value = this.compute();\n        }\n\n        if (NATIVE_TOUCH_ACTION && this.manager.element.style && TOUCH_ACTION_MAP[value]) {\n            this.manager.element.style[PREFIXED_TOUCH_ACTION] = value;\n        }\n        this.actions = value.toLowerCase().trim();\n    },\n\n    /**\n     * just re-set the touchAction value\n     */\n    update: function() {\n        this.set(this.manager.options.touchAction);\n    },\n\n    /**\n     * compute the value for the touchAction property based on the recognizer's settings\n     * @returns {String} value\n     */\n    compute: function() {\n        var actions = [];\n        each(this.manager.recognizers, function(recognizer) {\n            if (boolOrFn(recognizer.options.enable, [recognizer])) {\n                actions = actions.concat(recognizer.getTouchAction());\n            }\n        });\n        return cleanTouchActions(actions.join(' '));\n    },\n\n    /**\n     * this method is called on each input cycle and provides the preventing of the browser behavior\n     * @param {Object} input\n     */\n    preventDefaults: function(input) {\n        var srcEvent = input.srcEvent;\n        var direction = input.offsetDirection;\n\n        // if the touch action did prevented once this session\n        if (this.manager.session.prevented) {\n            srcEvent.preventDefault();\n            return;\n        }\n\n        var actions = this.actions;\n        var hasNone = inStr(actions, TOUCH_ACTION_NONE) && !TOUCH_ACTION_MAP[TOUCH_ACTION_NONE];\n        var hasPanY = inStr(actions, TOUCH_ACTION_PAN_Y) && !TOUCH_ACTION_MAP[TOUCH_ACTION_PAN_Y];\n        var hasPanX = inStr(actions, TOUCH_ACTION_PAN_X) && !TOUCH_ACTION_MAP[TOUCH_ACTION_PAN_X];\n\n        if (hasNone) {\n            //do not prevent defaults if this is a tap gesture\n\n            var isTapPointer = input.pointers.length === 1;\n            var isTapMovement = input.distance < 2;\n            var isTapTouchTime = input.deltaTime < 250;\n\n            if (isTapPointer && isTapMovement && isTapTouchTime) {\n                return;\n            }\n        }\n\n        if (hasPanX && hasPanY) {\n            // `pan-x pan-y` means browser handles all scrolling/panning, do not prevent\n            return;\n        }\n\n        if (hasNone ||\n            (hasPanY && direction & DIRECTION_HORIZONTAL) ||\n            (hasPanX && direction & DIRECTION_VERTICAL)) {\n            return this.preventSrc(srcEvent);\n        }\n    },\n\n    /**\n     * call preventDefault to prevent the browser's default behavior (scrolling in most cases)\n     * @param {Object} srcEvent\n     */\n    preventSrc: function(srcEvent) {\n        this.manager.session.prevented = true;\n        srcEvent.preventDefault();\n    }\n};\n\n/**\n * when the touchActions are collected they are not a valid value, so we need to clean things up. *\n * @param {String} actions\n * @returns {*}\n */\nfunction cleanTouchActions(actions) {\n    // none\n    if (inStr(actions, TOUCH_ACTION_NONE)) {\n        return TOUCH_ACTION_NONE;\n    }\n\n    var hasPanX = inStr(actions, TOUCH_ACTION_PAN_X);\n    var hasPanY = inStr(actions, TOUCH_ACTION_PAN_Y);\n\n    // if both pan-x and pan-y are set (different recognizers\n    // for different directions, e.g. horizontal pan but vertical swipe?)\n    // we need none (as otherwise with pan-x pan-y combined none of these\n    // recognizers will work, since the browser would handle all panning\n    if (hasPanX && hasPanY) {\n        return TOUCH_ACTION_NONE;\n    }\n\n    // pan-x OR pan-y\n    if (hasPanX || hasPanY) {\n        return hasPanX ? TOUCH_ACTION_PAN_X : TOUCH_ACTION_PAN_Y;\n    }\n\n    // manipulation\n    if (inStr(actions, TOUCH_ACTION_MANIPULATION)) {\n        return TOUCH_ACTION_MANIPULATION;\n    }\n\n    return TOUCH_ACTION_AUTO;\n}\n\nfunction getTouchActionProps() {\n    if (!NATIVE_TOUCH_ACTION) {\n        return false;\n    }\n    var touchMap = {};\n    var cssSupports = window.CSS && window.CSS.supports;\n    ['auto', 'manipulation', 'pan-y', 'pan-x', 'pan-x pan-y', 'none'].forEach(function(val) {\n\n        // If css.supports is not supported but there is native touch-action assume it supports\n        // all values. This is the case for IE 10 and 11.\n        touchMap[val] = cssSupports ? window.CSS.supports('touch-action', val) : true;\n    });\n    return touchMap;\n}\n\n/**\n * Recognizer flow explained; *\n * All recognizers have the initial state of POSSIBLE when a input session starts.\n * The definition of a input session is from the first input until the last input, with all it's movement in it. *\n * Example session for mouse-input: mousedown -> mousemove -> mouseup\n *\n * On each recognizing cycle (see Manager.recognize) the .recognize() method is executed\n * which determines with state it should be.\n *\n * If the recognizer has the state FAILED, CANCELLED or RECOGNIZED (equals ENDED), it is reset to\n * POSSIBLE to give it another change on the next cycle.\n *\n *               Possible\n *                  |\n *            +-----+---------------+\n *            |                     |\n *      +-----+-----+               |\n *      |           |               |\n *   Failed      Cancelled          |\n *                          +-------+------+\n *                          |              |\n *                      Recognized       Began\n *                                         |\n *                                      Changed\n *                                         |\n *                                  Ended/Recognized\n */\nvar STATE_POSSIBLE = 1;\nvar STATE_BEGAN = 2;\nvar STATE_CHANGED = 4;\nvar STATE_ENDED = 8;\nvar STATE_RECOGNIZED = STATE_ENDED;\nvar STATE_CANCELLED = 16;\nvar STATE_FAILED = 32;\n\n/**\n * Recognizer\n * Every recognizer needs to extend from this class.\n * @constructor\n * @param {Object} options\n */\nfunction Recognizer(options) {\n    this.options = assign({}, this.defaults, options || {});\n\n    this.id = uniqueId();\n\n    this.manager = null;\n\n    // default is enable true\n    this.options.enable = ifUndefined(this.options.enable, true);\n\n    this.state = STATE_POSSIBLE;\n\n    this.simultaneous = {};\n    this.requireFail = [];\n}\n\nRecognizer.prototype = {\n    /**\n     * @virtual\n     * @type {Object}\n     */\n    defaults: {},\n\n    /**\n     * set options\n     * @param {Object} options\n     * @return {Recognizer}\n     */\n    set: function(options) {\n        assign(this.options, options);\n\n        // also update the touchAction, in case something changed about the directions/enabled state\n        this.manager && this.manager.touchAction.update();\n        return this;\n    },\n\n    /**\n     * recognize simultaneous with an other recognizer.\n     * @param {Recognizer} otherRecognizer\n     * @returns {Recognizer} this\n     */\n    recognizeWith: function(otherRecognizer) {\n        if (invokeArrayArg(otherRecognizer, 'recognizeWith', this)) {\n            return this;\n        }\n\n        var simultaneous = this.simultaneous;\n        otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);\n        if (!simultaneous[otherRecognizer.id]) {\n            simultaneous[otherRecognizer.id] = otherRecognizer;\n            otherRecognizer.recognizeWith(this);\n        }\n        return this;\n    },\n\n    /**\n     * drop the simultaneous link. it doesnt remove the link on the other recognizer.\n     * @param {Recognizer} otherRecognizer\n     * @returns {Recognizer} this\n     */\n    dropRecognizeWith: function(otherRecognizer) {\n        if (invokeArrayArg(otherRecognizer, 'dropRecognizeWith', this)) {\n            return this;\n        }\n\n        otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);\n        delete this.simultaneous[otherRecognizer.id];\n        return this;\n    },\n\n    /**\n     * recognizer can only run when an other is failing\n     * @param {Recognizer} otherRecognizer\n     * @returns {Recognizer} this\n     */\n    requireFailure: function(otherRecognizer) {\n        if (invokeArrayArg(otherRecognizer, 'requireFailure', this)) {\n            return this;\n        }\n\n        var requireFail = this.requireFail;\n        otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);\n        if (inArray(requireFail, otherRecognizer) === -1) {\n            requireFail.push(otherRecognizer);\n            otherRecognizer.requireFailure(this);\n        }\n        return this;\n    },\n\n    /**\n     * drop the requireFailure link. it does not remove the link on the other recognizer.\n     * @param {Recognizer} otherRecognizer\n     * @returns {Recognizer} this\n     */\n    dropRequireFailure: function(otherRecognizer) {\n        if (invokeArrayArg(otherRecognizer, 'dropRequireFailure', this)) {\n            return this;\n        }\n\n        otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);\n        var index = inArray(this.requireFail, otherRecognizer);\n        if (index > -1) {\n            this.requireFail.splice(index, 1);\n        }\n        return this;\n    },\n\n    /**\n     * has require failures boolean\n     * @returns {boolean}\n     */\n    hasRequireFailures: function() {\n        return this.requireFail.length > 0;\n    },\n\n    /**\n     * if the recognizer can recognize simultaneous with an other recognizer\n     * @param {Recognizer} otherRecognizer\n     * @returns {Boolean}\n     */\n    canRecognizeWith: function(otherRecognizer) {\n        return !!this.simultaneous[otherRecognizer.id];\n    },\n\n    /**\n     * You should use `tryEmit` instead of `emit` directly to check\n     * that all the needed recognizers has failed before emitting.\n     * @param {Object} input\n     */\n    emit: function(input) {\n        var self = this;\n        var state = this.state;\n\n        function emit(event) {\n            self.manager.emit(event, input);\n        }\n\n        // 'panstart' and 'panmove'\n        if (state < STATE_ENDED) {\n            emit(self.options.event + stateStr(state));\n        }\n\n        emit(self.options.event); // simple 'eventName' events\n\n        if (input.additionalEvent) { // additional event(panleft, panright, pinchin, pinchout...)\n            emit(input.additionalEvent);\n        }\n\n        // panend and pancancel\n        if (state >= STATE_ENDED) {\n            emit(self.options.event + stateStr(state));\n        }\n    },\n\n    /**\n     * Check that all the require failure recognizers has failed,\n     * if true, it emits a gesture event,\n     * otherwise, setup the state to FAILED.\n     * @param {Object} input\n     */\n    tryEmit: function(input) {\n        if (this.canEmit()) {\n            return this.emit(input);\n        }\n        // it's failing anyway\n        this.state = STATE_FAILED;\n    },\n\n    /**\n     * can we emit?\n     * @returns {boolean}\n     */\n    canEmit: function() {\n        var i = 0;\n        while (i < this.requireFail.length) {\n            if (!(this.requireFail[i].state & (STATE_FAILED | STATE_POSSIBLE))) {\n                return false;\n            }\n            i++;\n        }\n        return true;\n    },\n\n    /**\n     * update the recognizer\n     * @param {Object} inputData\n     */\n    recognize: function(inputData) {\n        // make a new copy of the inputData\n        // so we can change the inputData without messing up the other recognizers\n        var inputDataClone = assign({}, inputData);\n\n        // is is enabled and allow recognizing?\n        if (!boolOrFn(this.options.enable, [this, inputDataClone])) {\n            this.reset();\n            this.state = STATE_FAILED;\n            return;\n        }\n\n        // reset when we've reached the end\n        if (this.state & (STATE_RECOGNIZED | STATE_CANCELLED | STATE_FAILED)) {\n            this.state = STATE_POSSIBLE;\n        }\n\n        this.state = this.process(inputDataClone);\n\n        // the recognizer has recognized a gesture\n        // so trigger an event\n        if (this.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED | STATE_CANCELLED)) {\n            this.tryEmit(inputDataClone);\n        }\n    },\n\n    /**\n     * return the state of the recognizer\n     * the actual recognizing happens in this method\n     * @virtual\n     * @param {Object} inputData\n     * @returns {Const} STATE\n     */\n    process: function(inputData) { }, // jshint ignore:line\n\n    /**\n     * return the preferred touch-action\n     * @virtual\n     * @returns {Array}\n     */\n    getTouchAction: function() { },\n\n    /**\n     * called when the gesture isn't allowed to recognize\n     * like when another is being recognized or it is disabled\n     * @virtual\n     */\n    reset: function() { }\n};\n\n/**\n * get a usable string, used as event postfix\n * @param {Const} state\n * @returns {String} state\n */\nfunction stateStr(state) {\n    if (state & STATE_CANCELLED) {\n        return 'cancel';\n    } else if (state & STATE_ENDED) {\n        return 'end';\n    } else if (state & STATE_CHANGED) {\n        return 'move';\n    } else if (state & STATE_BEGAN) {\n        return 'start';\n    }\n    return '';\n}\n\n/**\n * direction cons to string\n * @param {Const} direction\n * @returns {String}\n */\nfunction directionStr(direction) {\n    if (direction == DIRECTION_DOWN) {\n        return 'down';\n    } else if (direction == DIRECTION_UP) {\n        return 'up';\n    } else if (direction == DIRECTION_LEFT) {\n        return 'left';\n    } else if (direction == DIRECTION_RIGHT) {\n        return 'right';\n    }\n    return '';\n}\n\n/**\n * get a recognizer by name if it is bound to a manager\n * @param {Recognizer|String} otherRecognizer\n * @param {Recognizer} recognizer\n * @returns {Recognizer}\n */\nfunction getRecognizerByNameIfManager(otherRecognizer, recognizer) {\n    var manager = recognizer.manager;\n    if (manager) {\n        return manager.get(otherRecognizer);\n    }\n    return otherRecognizer;\n}\n\n/**\n * This recognizer is just used as a base for the simple attribute recognizers.\n * @constructor\n * @extends Recognizer\n */\nfunction AttrRecognizer() {\n    Recognizer.apply(this, arguments);\n}\n\ninherit(AttrRecognizer, Recognizer, {\n    /**\n     * @namespace\n     * @memberof AttrRecognizer\n     */\n    defaults: {\n        /**\n         * @type {Number}\n         * @default 1\n         */\n        pointers: 1\n    },\n\n    /**\n     * Used to check if it the recognizer receives valid input, like input.distance > 10.\n     * @memberof AttrRecognizer\n     * @param {Object} input\n     * @returns {Boolean} recognized\n     */\n    attrTest: function(input) {\n        var optionPointers = this.options.pointers;\n        return optionPointers === 0 || input.pointers.length === optionPointers;\n    },\n\n    /**\n     * Process the input and return the state for the recognizer\n     * @memberof AttrRecognizer\n     * @param {Object} input\n     * @returns {*} State\n     */\n    process: function(input) {\n        var state = this.state;\n        var eventType = input.eventType;\n\n        var isRecognized = state & (STATE_BEGAN | STATE_CHANGED);\n        var isValid = this.attrTest(input);\n\n        // on cancel input and we've recognized before, return STATE_CANCELLED\n        if (isRecognized && (eventType & INPUT_CANCEL || !isValid)) {\n            return state | STATE_CANCELLED;\n        } else if (isRecognized || isValid) {\n            if (eventType & INPUT_END) {\n                return state | STATE_ENDED;\n            } else if (!(state & STATE_BEGAN)) {\n                return STATE_BEGAN;\n            }\n            return state | STATE_CHANGED;\n        }\n        return STATE_FAILED;\n    }\n});\n\n/**\n * Pan\n * Recognized when the pointer is down and moved in the allowed direction.\n * @constructor\n * @extends AttrRecognizer\n */\nfunction PanRecognizer() {\n    AttrRecognizer.apply(this, arguments);\n\n    this.pX = null;\n    this.pY = null;\n}\n\ninherit(PanRecognizer, AttrRecognizer, {\n    /**\n     * @namespace\n     * @memberof PanRecognizer\n     */\n    defaults: {\n        event: 'pan',\n        threshold: 10,\n        pointers: 1,\n        direction: DIRECTION_ALL\n    },\n\n    getTouchAction: function() {\n        var direction = this.options.direction;\n        var actions = [];\n        if (direction & DIRECTION_HORIZONTAL) {\n            actions.push(TOUCH_ACTION_PAN_Y);\n        }\n        if (direction & DIRECTION_VERTICAL) {\n            actions.push(TOUCH_ACTION_PAN_X);\n        }\n        return actions;\n    },\n\n    directionTest: function(input) {\n        var options = this.options;\n        var hasMoved = true;\n        var distance = input.distance;\n        var direction = input.direction;\n        var x = input.deltaX;\n        var y = input.deltaY;\n\n        // lock to axis?\n        if (!(direction & options.direction)) {\n            if (options.direction & DIRECTION_HORIZONTAL) {\n                direction = (x === 0) ? DIRECTION_NONE : (x < 0) ? DIRECTION_LEFT : DIRECTION_RIGHT;\n                hasMoved = x != this.pX;\n                distance = Math.abs(input.deltaX);\n            } else {\n                direction = (y === 0) ? DIRECTION_NONE : (y < 0) ? DIRECTION_UP : DIRECTION_DOWN;\n                hasMoved = y != this.pY;\n                distance = Math.abs(input.deltaY);\n            }\n        }\n        input.direction = direction;\n        return hasMoved && distance > options.threshold && direction & options.direction;\n    },\n\n    attrTest: function(input) {\n        return AttrRecognizer.prototype.attrTest.call(this, input) &&\n            (this.state & STATE_BEGAN || (!(this.state & STATE_BEGAN) && this.directionTest(input)));\n    },\n\n    emit: function(input) {\n\n        this.pX = input.deltaX;\n        this.pY = input.deltaY;\n\n        var direction = directionStr(input.direction);\n\n        if (direction) {\n            input.additionalEvent = this.options.event + direction;\n        }\n        this._super.emit.call(this, input);\n    }\n});\n\n/**\n * Pinch\n * Recognized when two or more pointers are moving toward (zoom-in) or away from each other (zoom-out).\n * @constructor\n * @extends AttrRecognizer\n */\nfunction PinchRecognizer() {\n    AttrRecognizer.apply(this, arguments);\n}\n\ninherit(PinchRecognizer, AttrRecognizer, {\n    /**\n     * @namespace\n     * @memberof PinchRecognizer\n     */\n    defaults: {\n        event: 'pinch',\n        threshold: 0,\n        pointers: 2\n    },\n\n    getTouchAction: function() {\n        return [TOUCH_ACTION_NONE];\n    },\n\n    attrTest: function(input) {\n        return this._super.attrTest.call(this, input) &&\n            (Math.abs(input.scale - 1) > this.options.threshold || this.state & STATE_BEGAN);\n    },\n\n    emit: function(input) {\n        if (input.scale !== 1) {\n            var inOut = input.scale < 1 ? 'in' : 'out';\n            input.additionalEvent = this.options.event + inOut;\n        }\n        this._super.emit.call(this, input);\n    }\n});\n\n/**\n * Press\n * Recognized when the pointer is down for x ms without any movement.\n * @constructor\n * @extends Recognizer\n */\nfunction PressRecognizer() {\n    Recognizer.apply(this, arguments);\n\n    this._timer = null;\n    this._input = null;\n}\n\ninherit(PressRecognizer, Recognizer, {\n    /**\n     * @namespace\n     * @memberof PressRecognizer\n     */\n    defaults: {\n        event: 'press',\n        pointers: 1,\n        time: 251, // minimal time of the pointer to be pressed\n        threshold: 9 // a minimal movement is ok, but keep it low\n    },\n\n    getTouchAction: function() {\n        return [TOUCH_ACTION_AUTO];\n    },\n\n    process: function(input) {\n        var options = this.options;\n        var validPointers = input.pointers.length === options.pointers;\n        var validMovement = input.distance < options.threshold;\n        var validTime = input.deltaTime > options.time;\n\n        this._input = input;\n\n        // we only allow little movement\n        // and we've reached an end event, so a tap is possible\n        if (!validMovement || !validPointers || (input.eventType & (INPUT_END | INPUT_CANCEL) && !validTime)) {\n            this.reset();\n        } else if (input.eventType & INPUT_START) {\n            this.reset();\n            this._timer = setTimeoutContext(function() {\n                this.state = STATE_RECOGNIZED;\n                this.tryEmit();\n            }, options.time, this);\n        } else if (input.eventType & INPUT_END) {\n            return STATE_RECOGNIZED;\n        }\n        return STATE_FAILED;\n    },\n\n    reset: function() {\n        clearTimeout(this._timer);\n    },\n\n    emit: function(input) {\n        if (this.state !== STATE_RECOGNIZED) {\n            return;\n        }\n\n        if (input && (input.eventType & INPUT_END)) {\n            this.manager.emit(this.options.event + 'up', input);\n        } else {\n            this._input.timeStamp = now();\n            this.manager.emit(this.options.event, this._input);\n        }\n    }\n});\n\n/**\n * Rotate\n * Recognized when two or more pointer are moving in a circular motion.\n * @constructor\n * @extends AttrRecognizer\n */\nfunction RotateRecognizer() {\n    AttrRecognizer.apply(this, arguments);\n}\n\ninherit(RotateRecognizer, AttrRecognizer, {\n    /**\n     * @namespace\n     * @memberof RotateRecognizer\n     */\n    defaults: {\n        event: 'rotate',\n        threshold: 0,\n        pointers: 2\n    },\n\n    getTouchAction: function() {\n        return [TOUCH_ACTION_NONE];\n    },\n\n    attrTest: function(input) {\n        return this._super.attrTest.call(this, input) &&\n            (Math.abs(input.rotation) > this.options.threshold || this.state & STATE_BEGAN);\n    }\n});\n\n/**\n * Swipe\n * Recognized when the pointer is moving fast (velocity), with enough distance in the allowed direction.\n * @constructor\n * @extends AttrRecognizer\n */\nfunction SwipeRecognizer() {\n    AttrRecognizer.apply(this, arguments);\n}\n\ninherit(SwipeRecognizer, AttrRecognizer, {\n    /**\n     * @namespace\n     * @memberof SwipeRecognizer\n     */\n    defaults: {\n        event: 'swipe',\n        threshold: 10,\n        velocity: 0.3,\n        direction: DIRECTION_HORIZONTAL | DIRECTION_VERTICAL,\n        pointers: 1\n    },\n\n    getTouchAction: function() {\n        return PanRecognizer.prototype.getTouchAction.call(this);\n    },\n\n    attrTest: function(input) {\n        var direction = this.options.direction;\n        var velocity;\n\n        if (direction & (DIRECTION_HORIZONTAL | DIRECTION_VERTICAL)) {\n            velocity = input.overallVelocity;\n        } else if (direction & DIRECTION_HORIZONTAL) {\n            velocity = input.overallVelocityX;\n        } else if (direction & DIRECTION_VERTICAL) {\n            velocity = input.overallVelocityY;\n        }\n\n        return this._super.attrTest.call(this, input) &&\n            direction & input.offsetDirection &&\n            input.distance > this.options.threshold &&\n            input.maxPointers == this.options.pointers &&\n            abs(velocity) > this.options.velocity && input.eventType & INPUT_END;\n    },\n\n    emit: function(input) {\n        var direction = directionStr(input.offsetDirection);\n        if (direction) {\n            this.manager.emit(this.options.event + direction, input);\n        }\n\n        this.manager.emit(this.options.event, input);\n    }\n});\n\n/**\n * A tap is ecognized when the pointer is doing a small tap/click. Multiple taps are recognized if they occur\n * between the given interval and position. The delay option can be used to recognize multi-taps without firing\n * a single tap.\n *\n * The eventData from the emitted event contains the property `tapCount`, which contains the amount of\n * multi-taps being recognized.\n * @constructor\n * @extends Recognizer\n */\nfunction TapRecognizer() {\n    Recognizer.apply(this, arguments);\n\n    // previous time and center,\n    // used for tap counting\n    this.pTime = false;\n    this.pCenter = false;\n\n    this._timer = null;\n    this._input = null;\n    this.count = 0;\n}\n\ninherit(TapRecognizer, Recognizer, {\n    /**\n     * @namespace\n     * @memberof PinchRecognizer\n     */\n    defaults: {\n        event: 'tap',\n        pointers: 1,\n        taps: 1,\n        interval: 300, // max time between the multi-tap taps\n        time: 250, // max time of the pointer to be down (like finger on the screen)\n        threshold: 9, // a minimal movement is ok, but keep it low\n        posThreshold: 10 // a multi-tap can be a bit off the initial position\n    },\n\n    getTouchAction: function() {\n        return [TOUCH_ACTION_MANIPULATION];\n    },\n\n    process: function(input) {\n        var options = this.options;\n\n        var validPointers = input.pointers.length === options.pointers;\n        var validMovement = input.distance < options.threshold;\n        var validTouchTime = input.deltaTime < options.time;\n\n        this.reset();\n\n        if ((input.eventType & INPUT_START) && (this.count === 0)) {\n            return this.failTimeout();\n        }\n\n        // we only allow little movement\n        // and we've reached an end event, so a tap is possible\n        if (validMovement && validTouchTime && validPointers) {\n            if (input.eventType != INPUT_END) {\n                return this.failTimeout();\n            }\n\n            var validInterval = this.pTime ? (input.timeStamp - this.pTime < options.interval) : true;\n            var validMultiTap = !this.pCenter || getDistance(this.pCenter, input.center) < options.posThreshold;\n\n            this.pTime = input.timeStamp;\n            this.pCenter = input.center;\n\n            if (!validMultiTap || !validInterval) {\n                this.count = 1;\n            } else {\n                this.count += 1;\n            }\n\n            this._input = input;\n\n            // if tap count matches we have recognized it,\n            // else it has began recognizing...\n            var tapCount = this.count % options.taps;\n            if (tapCount === 0) {\n                // no failing requirements, immediately trigger the tap event\n                // or wait as long as the multitap interval to trigger\n                if (!this.hasRequireFailures()) {\n                    return STATE_RECOGNIZED;\n                } else {\n                    this._timer = setTimeoutContext(function() {\n                        this.state = STATE_RECOGNIZED;\n                        this.tryEmit();\n                    }, options.interval, this);\n                    return STATE_BEGAN;\n                }\n            }\n        }\n        return STATE_FAILED;\n    },\n\n    failTimeout: function() {\n        this._timer = setTimeoutContext(function() {\n            this.state = STATE_FAILED;\n        }, this.options.interval, this);\n        return STATE_FAILED;\n    },\n\n    reset: function() {\n        clearTimeout(this._timer);\n    },\n\n    emit: function() {\n        if (this.state == STATE_RECOGNIZED) {\n            this._input.tapCount = this.count;\n            this.manager.emit(this.options.event, this._input);\n        }\n    }\n});\n\n/**\n * Simple way to create a manager with a default set of recognizers.\n * @param {HTMLElement} element\n * @param {Object} [options]\n * @constructor\n */\nfunction Hammer(element, options) {\n    options = options || {};\n    options.recognizers = ifUndefined(options.recognizers, Hammer.defaults.preset);\n    return new Manager(element, options);\n}\n\n/**\n * @const {string}\n */\nHammer.VERSION = '2.0.7';\n\n/**\n * default settings\n * @namespace\n */\nHammer.defaults = {\n    /**\n     * set if DOM events are being triggered.\n     * But this is slower and unused by simple implementations, so disabled by default.\n     * @type {Boolean}\n     * @default false\n     */\n    domEvents: false,\n\n    /**\n     * The value for the touchAction property/fallback.\n     * When set to `compute` it will magically set the correct value based on the added recognizers.\n     * @type {String}\n     * @default compute\n     */\n    touchAction: TOUCH_ACTION_COMPUTE,\n\n    /**\n     * @type {Boolean}\n     * @default true\n     */\n    enable: true,\n\n    /**\n     * EXPERIMENTAL FEATURE -- can be removed/changed\n     * Change the parent input target element.\n     * If Null, then it is being set the to main element.\n     * @type {Null|EventTarget}\n     * @default null\n     */\n    inputTarget: null,\n\n    /**\n     * force an input class\n     * @type {Null|Function}\n     * @default null\n     */\n    inputClass: null,\n\n    /**\n     * Default recognizer setup when calling `Hammer()`\n     * When creating a new Manager these will be skipped.\n     * @type {Array}\n     */\n    preset: [\n        // RecognizerClass, options, [recognizeWith, ...], [requireFailure, ...]\n        [RotateRecognizer, {enable: false}],\n        [PinchRecognizer, {enable: false}, ['rotate']],\n        [SwipeRecognizer, {direction: DIRECTION_HORIZONTAL}],\n        [PanRecognizer, {direction: DIRECTION_HORIZONTAL}, ['swipe']],\n        [TapRecognizer],\n        [TapRecognizer, {event: 'doubletap', taps: 2}, ['tap']],\n        [PressRecognizer]\n    ],\n\n    /**\n     * Some CSS properties can be used to improve the working of Hammer.\n     * Add them to this method and they will be set when creating a new Manager.\n     * @namespace\n     */\n    cssProps: {\n        /**\n         * Disables text selection to improve the dragging gesture. Mainly for desktop browsers.\n         * @type {String}\n         * @default 'none'\n         */\n        userSelect: 'none',\n\n        /**\n         * Disable the Windows Phone grippers when pressing an element.\n         * @type {String}\n         * @default 'none'\n         */\n        touchSelect: 'none',\n\n        /**\n         * Disables the default callout shown when you touch and hold a touch target.\n         * On iOS, when you touch and hold a touch target such as a link, Safari displays\n         * a callout containing information about the link. This property allows you to disable that callout.\n         * @type {String}\n         * @default 'none'\n         */\n        touchCallout: 'none',\n\n        /**\n         * Specifies whether zooming is enabled. Used by IE10>\n         * @type {String}\n         * @default 'none'\n         */\n        contentZooming: 'none',\n\n        /**\n         * Specifies that an entire element should be draggable instead of its contents. Mainly for desktop browsers.\n         * @type {String}\n         * @default 'none'\n         */\n        userDrag: 'none',\n\n        /**\n         * Overrides the highlight color shown when the user taps a link or a JavaScript\n         * clickable element in iOS. This property obeys the alpha value, if specified.\n         * @type {String}\n         * @default 'rgba(0,0,0,0)'\n         */\n        tapHighlightColor: 'rgba(0,0,0,0)'\n    }\n};\n\nvar STOP = 1;\nvar FORCED_STOP = 2;\n\n/**\n * Manager\n * @param {HTMLElement} element\n * @param {Object} [options]\n * @constructor\n */\nfunction Manager(element, options) {\n    this.options = assign({}, Hammer.defaults, options || {});\n\n    this.options.inputTarget = this.options.inputTarget || element;\n\n    this.handlers = {};\n    this.session = {};\n    this.recognizers = [];\n    this.oldCssProps = {};\n\n    this.element = element;\n    this.input = createInputInstance(this);\n    this.touchAction = new TouchAction(this, this.options.touchAction);\n\n    toggleCssProps(this, true);\n\n    each(this.options.recognizers, function(item) {\n        var recognizer = this.add(new (item[0])(item[1]));\n        item[2] && recognizer.recognizeWith(item[2]);\n        item[3] && recognizer.requireFailure(item[3]);\n    }, this);\n}\n\nManager.prototype = {\n    /**\n     * set options\n     * @param {Object} options\n     * @returns {Manager}\n     */\n    set: function(options) {\n        assign(this.options, options);\n\n        // Options that need a little more setup\n        if (options.touchAction) {\n            this.touchAction.update();\n        }\n        if (options.inputTarget) {\n            // Clean up existing event listeners and reinitialize\n            this.input.destroy();\n            this.input.target = options.inputTarget;\n            this.input.init();\n        }\n        return this;\n    },\n\n    /**\n     * stop recognizing for this session.\n     * This session will be discarded, when a new [input]start event is fired.\n     * When forced, the recognizer cycle is stopped immediately.\n     * @param {Boolean} [force]\n     */\n    stop: function(force) {\n        this.session.stopped = force ? FORCED_STOP : STOP;\n    },\n\n    /**\n     * run the recognizers!\n     * called by the inputHandler function on every movement of the pointers (touches)\n     * it walks through all the recognizers and tries to detect the gesture that is being made\n     * @param {Object} inputData\n     */\n    recognize: function(inputData) {\n        var session = this.session;\n        if (session.stopped) {\n            return;\n        }\n\n        // run the touch-action polyfill\n        this.touchAction.preventDefaults(inputData);\n\n        var recognizer;\n        var recognizers = this.recognizers;\n\n        // this holds the recognizer that is being recognized.\n        // so the recognizer's state needs to be BEGAN, CHANGED, ENDED or RECOGNIZED\n        // if no recognizer is detecting a thing, it is set to `null`\n        var curRecognizer = session.curRecognizer;\n\n        // reset when the last recognizer is recognized\n        // or when we're in a new session\n        if (!curRecognizer || (curRecognizer && curRecognizer.state & STATE_RECOGNIZED)) {\n            curRecognizer = session.curRecognizer = null;\n        }\n\n        var i = 0;\n        while (i < recognizers.length) {\n            recognizer = recognizers[i];\n\n            // find out if we are allowed try to recognize the input for this one.\n            // 1.   allow if the session is NOT forced stopped (see the .stop() method)\n            // 2.   allow if we still haven't recognized a gesture in this session, or the this recognizer is the one\n            //      that is being recognized.\n            // 3.   allow if the recognizer is allowed to run simultaneous with the current recognized recognizer.\n            //      this can be setup with the `recognizeWith()` method on the recognizer.\n            if (session.stopped !== FORCED_STOP && ( // 1\n                    !curRecognizer || recognizer == curRecognizer || // 2\n                    recognizer.canRecognizeWith(curRecognizer))) { // 3\n                recognizer.recognize(inputData);\n            } else {\n                recognizer.reset();\n            }\n\n            // if the recognizer has been recognizing the input as a valid gesture, we want to store this one as the\n            // current active recognizer. but only if we don't already have an active recognizer\n            if (!curRecognizer && recognizer.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED)) {\n                curRecognizer = session.curRecognizer = recognizer;\n            }\n            i++;\n        }\n    },\n\n    /**\n     * get a recognizer by its event name.\n     * @param {Recognizer|String} recognizer\n     * @returns {Recognizer|Null}\n     */\n    get: function(recognizer) {\n        if (recognizer instanceof Recognizer) {\n            return recognizer;\n        }\n\n        var recognizers = this.recognizers;\n        for (var i = 0; i < recognizers.length; i++) {\n            if (recognizers[i].options.event == recognizer) {\n                return recognizers[i];\n            }\n        }\n        return null;\n    },\n\n    /**\n     * add a recognizer to the manager\n     * existing recognizers with the same event name will be removed\n     * @param {Recognizer} recognizer\n     * @returns {Recognizer|Manager}\n     */\n    add: function(recognizer) {\n        if (invokeArrayArg(recognizer, 'add', this)) {\n            return this;\n        }\n\n        // remove existing\n        var existing = this.get(recognizer.options.event);\n        if (existing) {\n            this.remove(existing);\n        }\n\n        this.recognizers.push(recognizer);\n        recognizer.manager = this;\n\n        this.touchAction.update();\n        return recognizer;\n    },\n\n    /**\n     * remove a recognizer by name or instance\n     * @param {Recognizer|String} recognizer\n     * @returns {Manager}\n     */\n    remove: function(recognizer) {\n        if (invokeArrayArg(recognizer, 'remove', this)) {\n            return this;\n        }\n\n        recognizer = this.get(recognizer);\n\n        // let's make sure this recognizer exists\n        if (recognizer) {\n            var recognizers = this.recognizers;\n            var index = inArray(recognizers, recognizer);\n\n            if (index !== -1) {\n                recognizers.splice(index, 1);\n                this.touchAction.update();\n            }\n        }\n\n        return this;\n    },\n\n    /**\n     * bind event\n     * @param {String} events\n     * @param {Function} handler\n     * @returns {EventEmitter} this\n     */\n    on: function(events, handler) {\n        if (events === undefined) {\n            return;\n        }\n        if (handler === undefined) {\n            return;\n        }\n\n        var handlers = this.handlers;\n        each(splitStr(events), function(event) {\n            handlers[event] = handlers[event] || [];\n            handlers[event].push(handler);\n        });\n        return this;\n    },\n\n    /**\n     * unbind event, leave emit blank to remove all handlers\n     * @param {String} events\n     * @param {Function} [handler]\n     * @returns {EventEmitter} this\n     */\n    off: function(events, handler) {\n        if (events === undefined) {\n            return;\n        }\n\n        var handlers = this.handlers;\n        each(splitStr(events), function(event) {\n            if (!handler) {\n                delete handlers[event];\n            } else {\n                handlers[event] && handlers[event].splice(inArray(handlers[event], handler), 1);\n            }\n        });\n        return this;\n    },\n\n    /**\n     * emit event to the listeners\n     * @param {String} event\n     * @param {Object} data\n     */\n    emit: function(event, data) {\n        // we also want to trigger dom events\n        if (this.options.domEvents) {\n            triggerDomEvent(event, data);\n        }\n\n        // no handlers, so skip it all\n        var handlers = this.handlers[event] && this.handlers[event].slice();\n        if (!handlers || !handlers.length) {\n            return;\n        }\n\n        data.type = event;\n        data.preventDefault = function() {\n            data.srcEvent.preventDefault();\n        };\n\n        var i = 0;\n        while (i < handlers.length) {\n            handlers[i](data);\n            i++;\n        }\n    },\n\n    /**\n     * destroy the manager and unbinds all events\n     * it doesn't unbind dom events, that is the user own responsibility\n     */\n    destroy: function() {\n        this.element && toggleCssProps(this, false);\n\n        this.handlers = {};\n        this.session = {};\n        this.input.destroy();\n        this.element = null;\n    }\n};\n\n/**\n * add/remove the css properties as defined in manager.options.cssProps\n * @param {Manager} manager\n * @param {Boolean} add\n */\nfunction toggleCssProps(manager, add) {\n    var element = manager.element;\n    if (!element.style) {\n        return;\n    }\n    var prop;\n    each(manager.options.cssProps, function(value, name) {\n        prop = prefixed(element.style, name);\n        if (add) {\n            manager.oldCssProps[prop] = element.style[prop];\n            element.style[prop] = value;\n        } else {\n            element.style[prop] = manager.oldCssProps[prop] || '';\n        }\n    });\n    if (!add) {\n        manager.oldCssProps = {};\n    }\n}\n\n/**\n * trigger dom event\n * @param {String} event\n * @param {Object} data\n */\nfunction triggerDomEvent(event, data) {\n    var gestureEvent = document.createEvent('Event');\n    gestureEvent.initEvent(event, true, true);\n    gestureEvent.gesture = data;\n    data.target.dispatchEvent(gestureEvent);\n}\n\nassign(Hammer, {\n    INPUT_START: INPUT_START,\n    INPUT_MOVE: INPUT_MOVE,\n    INPUT_END: INPUT_END,\n    INPUT_CANCEL: INPUT_CANCEL,\n\n    STATE_POSSIBLE: STATE_POSSIBLE,\n    STATE_BEGAN: STATE_BEGAN,\n    STATE_CHANGED: STATE_CHANGED,\n    STATE_ENDED: STATE_ENDED,\n    STATE_RECOGNIZED: STATE_RECOGNIZED,\n    STATE_CANCELLED: STATE_CANCELLED,\n    STATE_FAILED: STATE_FAILED,\n\n    DIRECTION_NONE: DIRECTION_NONE,\n    DIRECTION_LEFT: DIRECTION_LEFT,\n    DIRECTION_RIGHT: DIRECTION_RIGHT,\n    DIRECTION_UP: DIRECTION_UP,\n    DIRECTION_DOWN: DIRECTION_DOWN,\n    DIRECTION_HORIZONTAL: DIRECTION_HORIZONTAL,\n    DIRECTION_VERTICAL: DIRECTION_VERTICAL,\n    DIRECTION_ALL: DIRECTION_ALL,\n\n    Manager: Manager,\n    Input: Input,\n    TouchAction: TouchAction,\n\n    TouchInput: TouchInput,\n    MouseInput: MouseInput,\n    PointerEventInput: PointerEventInput,\n    TouchMouseInput: TouchMouseInput,\n    SingleTouchInput: SingleTouchInput,\n\n    Recognizer: Recognizer,\n    AttrRecognizer: AttrRecognizer,\n    Tap: TapRecognizer,\n    Pan: PanRecognizer,\n    Swipe: SwipeRecognizer,\n    Pinch: PinchRecognizer,\n    Rotate: RotateRecognizer,\n    Press: PressRecognizer,\n\n    on: addEventListeners,\n    off: removeEventListeners,\n    each: each,\n    merge: merge,\n    extend: extend,\n    assign: assign,\n    inherit: inherit,\n    bindFn: bindFn,\n    prefixed: prefixed\n});\n\n// this prevents errors when Hammer is loaded in the presence of an AMD\n//  style loader but by script tag, not by the loader.\nvar freeGlobal = (typeof window !== 'undefined' ? window : (typeof self !== 'undefined' ? self : {})); // jshint ignore:line\nfreeGlobal.Hammer = Hammer;\n\nif (typeof define === 'function' && define.amd) {\n    define(function() {\n        return Hammer;\n    });\n} else if (typeof module != 'undefined' && module.exports) {\n    module.exports = Hammer;\n} else {\n    window[exportName] = Hammer;\n}\n\n})(window, document, 'Hammer');\n","/**\n * lodash (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright jQuery Foundation and other contributors <https://jquery.org/>\n * Released under MIT license <https://lodash.com/license>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n */\n\n/** Used as the `TypeError` message for \"Functions\" methods. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/** Used as references for various `Number` constants. */\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]',\n    funcTag = '[object Function]',\n    genTag = '[object GeneratorFunction]';\n\n/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\n/**\n * A faster alternative to `Function#apply`, this function invokes `func`\n * with the `this` binding of `thisArg` and the arguments of `args`.\n *\n * @private\n * @param {Function} func The function to invoke.\n * @param {*} thisArg The `this` binding of `func`.\n * @param {Array} args The arguments to invoke `func` with.\n * @returns {*} Returns the result of `func`.\n */\nfunction apply(func, thisArg, args) {\n  switch (args.length) {\n    case 0: return func.call(thisArg);\n    case 1: return func.call(thisArg, args[0]);\n    case 2: return func.call(thisArg, args[0], args[1]);\n    case 3: return func.call(thisArg, args[0], args[1], args[2]);\n  }\n  return func.apply(thisArg, args);\n}\n\n/**\n * Appends the elements of `values` to `array`.\n *\n * @private\n * @param {Array} array The array to modify.\n * @param {Array} values The values to append.\n * @returns {Array} Returns `array`.\n */\nfunction arrayPush(array, values) {\n  var index = -1,\n      length = values.length,\n      offset = array.length;\n\n  while (++index < length) {\n    array[offset + index] = values[index];\n  }\n  return array;\n}\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar objectToString = objectProto.toString;\n\n/** Built-in value references. */\nvar Symbol = root.Symbol,\n    propertyIsEnumerable = objectProto.propertyIsEnumerable,\n    spreadableSymbol = Symbol ? Symbol.isConcatSpreadable : undefined;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max;\n\n/**\n * The base implementation of `_.flatten` with support for restricting flattening.\n *\n * @private\n * @param {Array} array The array to flatten.\n * @param {number} depth The maximum recursion depth.\n * @param {boolean} [predicate=isFlattenable] The function invoked per iteration.\n * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks.\n * @param {Array} [result=[]] The initial result value.\n * @returns {Array} Returns the new flattened array.\n */\nfunction baseFlatten(array, depth, predicate, isStrict, result) {\n  var index = -1,\n      length = array.length;\n\n  predicate || (predicate = isFlattenable);\n  result || (result = []);\n\n  while (++index < length) {\n    var value = array[index];\n    if (depth > 0 && predicate(value)) {\n      if (depth > 1) {\n        // Recursively flatten arrays (susceptible to call stack limits).\n        baseFlatten(value, depth - 1, predicate, isStrict, result);\n      } else {\n        arrayPush(result, value);\n      }\n    } else if (!isStrict) {\n      result[result.length] = value;\n    }\n  }\n  return result;\n}\n\n/**\n * The base implementation of `_.rest` which doesn't validate or coerce arguments.\n *\n * @private\n * @param {Function} func The function to apply a rest parameter to.\n * @param {number} [start=func.length-1] The start position of the rest parameter.\n * @returns {Function} Returns the new function.\n */\nfunction baseRest(func, start) {\n  start = nativeMax(start === undefined ? (func.length - 1) : start, 0);\n  return function() {\n    var args = arguments,\n        index = -1,\n        length = nativeMax(args.length - start, 0),\n        array = Array(length);\n\n    while (++index < length) {\n      array[index] = args[start + index];\n    }\n    index = -1;\n    var otherArgs = Array(start + 1);\n    while (++index < start) {\n      otherArgs[index] = args[index];\n    }\n    otherArgs[start] = array;\n    return apply(func, this, otherArgs);\n  };\n}\n\n/**\n * Creates a `_.flow` or `_.flowRight` function.\n *\n * @private\n * @param {boolean} [fromRight] Specify iterating from right to left.\n * @returns {Function} Returns the new flow function.\n */\nfunction createFlow(fromRight) {\n  return baseRest(function(funcs) {\n    funcs = baseFlatten(funcs, 1);\n\n    var length = funcs.length,\n        index = length;\n\n    if (fromRight) {\n      funcs.reverse();\n    }\n    while (index--) {\n      if (typeof funcs[index] != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n    }\n    return function() {\n      var index = 0,\n          result = length ? funcs[index].apply(this, arguments) : arguments[0];\n\n      while (++index < length) {\n        result = funcs[index].call(this, result);\n      }\n      return result;\n    };\n  });\n}\n\n/**\n * Checks if `value` is a flattenable `arguments` object or array.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is flattenable, else `false`.\n */\nfunction isFlattenable(value) {\n  return isArray(value) || isArguments(value) ||\n    !!(spreadableSymbol && value && value[spreadableSymbol]);\n}\n\n/**\n * Checks if `value` is likely an `arguments` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n *  else `false`.\n * @example\n *\n * _.isArguments(function() { return arguments; }());\n * // => true\n *\n * _.isArguments([1, 2, 3]);\n * // => false\n */\nfunction isArguments(value) {\n  // Safari 8.1 makes `arguments.callee` enumerable in strict mode.\n  return isArrayLikeObject(value) && hasOwnProperty.call(value, 'callee') &&\n    (!propertyIsEnumerable.call(value, 'callee') || objectToString.call(value) == argsTag);\n}\n\n/**\n * Checks if `value` is classified as an `Array` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array, else `false`.\n * @example\n *\n * _.isArray([1, 2, 3]);\n * // => true\n *\n * _.isArray(document.body.children);\n * // => false\n *\n * _.isArray('abc');\n * // => false\n *\n * _.isArray(_.noop);\n * // => false\n */\nvar isArray = Array.isArray;\n\n/**\n * Checks if `value` is array-like. A value is considered array-like if it's\n * not a function and has a `value.length` that's an integer greater than or\n * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n * @example\n *\n * _.isArrayLike([1, 2, 3]);\n * // => true\n *\n * _.isArrayLike(document.body.children);\n * // => true\n *\n * _.isArrayLike('abc');\n * // => true\n *\n * _.isArrayLike(_.noop);\n * // => false\n */\nfunction isArrayLike(value) {\n  return value != null && isLength(value.length) && !isFunction(value);\n}\n\n/**\n * This method is like `_.isArrayLike` except that it also checks if `value`\n * is an object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array-like object,\n *  else `false`.\n * @example\n *\n * _.isArrayLikeObject([1, 2, 3]);\n * // => true\n *\n * _.isArrayLikeObject(document.body.children);\n * // => true\n *\n * _.isArrayLikeObject('abc');\n * // => false\n *\n * _.isArrayLikeObject(_.noop);\n * // => false\n */\nfunction isArrayLikeObject(value) {\n  return isObjectLike(value) && isArrayLike(value);\n}\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a function, else `false`.\n * @example\n *\n * _.isFunction(_);\n * // => true\n *\n * _.isFunction(/abc/);\n * // => false\n */\nfunction isFunction(value) {\n  // The use of `Object#toString` avoids issues with the `typeof` operator\n  // in Safari 8-9 which returns 'object' for typed array and other constructors.\n  var tag = isObject(value) ? objectToString.call(value) : '';\n  return tag == funcTag || tag == genTag;\n}\n\n/**\n * Checks if `value` is a valid array-like length.\n *\n * **Note:** This method is loosely based on\n * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n * @example\n *\n * _.isLength(3);\n * // => true\n *\n * _.isLength(Number.MIN_VALUE);\n * // => false\n *\n * _.isLength(Infinity);\n * // => false\n *\n * _.isLength('3');\n * // => false\n */\nfunction isLength(value) {\n  return typeof value == 'number' &&\n    value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n}\n\n/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return !!value && (type == 'object' || type == 'function');\n}\n\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return !!value && typeof value == 'object';\n}\n\n/**\n * This method is like `_.flow` except that it creates a function that\n * invokes the given functions from right to left.\n *\n * @static\n * @since 3.0.0\n * @memberOf _\n * @category Util\n * @param {...(Function|Function[])} [funcs] The functions to invoke.\n * @returns {Function} Returns the new composite function.\n * @see _.flow\n * @example\n *\n * function square(n) {\n *   return n * n;\n * }\n *\n * var addSquare = _.flowRight([square, _.add]);\n * addSquare(1, 2);\n * // => 9\n */\nvar flowRight = createFlow(true);\n\nmodule.exports = flowRight;\n","/**\n * Lodash (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright OpenJS Foundation and other contributors <https://openjsf.org/>\n * Released under MIT license <https://lodash.com/license>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n */\n\n/** Used as the size to enable large array optimizations. */\nvar LARGE_ARRAY_SIZE = 200;\n\n/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/** Used to detect hot functions by number of calls within a span of milliseconds. */\nvar HOT_COUNT = 800,\n    HOT_SPAN = 16;\n\n/** Used as references for various `Number` constants. */\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]',\n    arrayTag = '[object Array]',\n    asyncTag = '[object AsyncFunction]',\n    boolTag = '[object Boolean]',\n    dateTag = '[object Date]',\n    errorTag = '[object Error]',\n    funcTag = '[object Function]',\n    genTag = '[object GeneratorFunction]',\n    mapTag = '[object Map]',\n    numberTag = '[object Number]',\n    nullTag = '[object Null]',\n    objectTag = '[object Object]',\n    proxyTag = '[object Proxy]',\n    regexpTag = '[object RegExp]',\n    setTag = '[object Set]',\n    stringTag = '[object String]',\n    undefinedTag = '[object Undefined]',\n    weakMapTag = '[object WeakMap]';\n\nvar arrayBufferTag = '[object ArrayBuffer]',\n    dataViewTag = '[object DataView]',\n    float32Tag = '[object Float32Array]',\n    float64Tag = '[object Float64Array]',\n    int8Tag = '[object Int8Array]',\n    int16Tag = '[object Int16Array]',\n    int32Tag = '[object Int32Array]',\n    uint8Tag = '[object Uint8Array]',\n    uint8ClampedTag = '[object Uint8ClampedArray]',\n    uint16Tag = '[object Uint16Array]',\n    uint32Tag = '[object Uint32Array]';\n\n/**\n * Used to match `RegExp`\n * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).\n */\nvar reRegExpChar = /[\\\\^$.*+?()[\\]{}|]/g;\n\n/** Used to detect host constructors (Safari). */\nvar reIsHostCtor = /^\\[object .+?Constructor\\]$/;\n\n/** Used to detect unsigned integer values. */\nvar reIsUint = /^(?:0|[1-9]\\d*)$/;\n\n/** Used to identify `toStringTag` values of typed arrays. */\nvar typedArrayTags = {};\ntypedArrayTags[float32Tag] = typedArrayTags[float64Tag] =\ntypedArrayTags[int8Tag] = typedArrayTags[int16Tag] =\ntypedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =\ntypedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =\ntypedArrayTags[uint32Tag] = true;\ntypedArrayTags[argsTag] = typedArrayTags[arrayTag] =\ntypedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =\ntypedArrayTags[dataViewTag] = typedArrayTags[dateTag] =\ntypedArrayTags[errorTag] = typedArrayTags[funcTag] =\ntypedArrayTags[mapTag] = typedArrayTags[numberTag] =\ntypedArrayTags[objectTag] = typedArrayTags[regexpTag] =\ntypedArrayTags[setTag] = typedArrayTags[stringTag] =\ntypedArrayTags[weakMapTag] = false;\n\n/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\n/** Detect free variable `exports`. */\nvar freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/** Detect free variable `process` from Node.js. */\nvar freeProcess = moduleExports && freeGlobal.process;\n\n/** Used to access faster Node.js helpers. */\nvar nodeUtil = (function() {\n  try {\n    // Use `util.types` for Node.js 10+.\n    var types = freeModule && freeModule.require && freeModule.require('util').types;\n\n    if (types) {\n      return types;\n    }\n\n    // Legacy `process.binding('util')` for Node.js < 10.\n    return freeProcess && freeProcess.binding && freeProcess.binding('util');\n  } catch (e) {}\n}());\n\n/* Node.js helper references. */\nvar nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;\n\n/**\n * A faster alternative to `Function#apply`, this function invokes `func`\n * with the `this` binding of `thisArg` and the arguments of `args`.\n *\n * @private\n * @param {Function} func The function to invoke.\n * @param {*} thisArg The `this` binding of `func`.\n * @param {Array} args The arguments to invoke `func` with.\n * @returns {*} Returns the result of `func`.\n */\nfunction apply(func, thisArg, args) {\n  switch (args.length) {\n    case 0: return func.call(thisArg);\n    case 1: return func.call(thisArg, args[0]);\n    case 2: return func.call(thisArg, args[0], args[1]);\n    case 3: return func.call(thisArg, args[0], args[1], args[2]);\n  }\n  return func.apply(thisArg, args);\n}\n\n/**\n * The base implementation of `_.times` without support for iteratee shorthands\n * or max array length checks.\n *\n * @private\n * @param {number} n The number of times to invoke `iteratee`.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the array of results.\n */\nfunction baseTimes(n, iteratee) {\n  var index = -1,\n      result = Array(n);\n\n  while (++index < n) {\n    result[index] = iteratee(index);\n  }\n  return result;\n}\n\n/**\n * The base implementation of `_.unary` without support for storing metadata.\n *\n * @private\n * @param {Function} func The function to cap arguments for.\n * @returns {Function} Returns the new capped function.\n */\nfunction baseUnary(func) {\n  return function(value) {\n    return func(value);\n  };\n}\n\n/**\n * Gets the value at `key` of `object`.\n *\n * @private\n * @param {Object} [object] The object to query.\n * @param {string} key The key of the property to get.\n * @returns {*} Returns the property value.\n */\nfunction getValue(object, key) {\n  return object == null ? undefined : object[key];\n}\n\n/**\n * Creates a unary function that invokes `func` with its argument transformed.\n *\n * @private\n * @param {Function} func The function to wrap.\n * @param {Function} transform The argument transform.\n * @returns {Function} Returns the new function.\n */\nfunction overArg(func, transform) {\n  return function(arg) {\n    return func(transform(arg));\n  };\n}\n\n/** Used for built-in method references. */\nvar arrayProto = Array.prototype,\n    funcProto = Function.prototype,\n    objectProto = Object.prototype;\n\n/** Used to detect overreaching core-js shims. */\nvar coreJsData = root['__core-js_shared__'];\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Used to detect methods masquerading as native. */\nvar maskSrcKey = (function() {\n  var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');\n  return uid ? ('Symbol(src)_1.' + uid) : '';\n}());\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/** Used to infer the `Object` constructor. */\nvar objectCtorString = funcToString.call(Object);\n\n/** Used to detect if a method is native. */\nvar reIsNative = RegExp('^' +\n  funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\\\$&')\n  .replace(/hasOwnProperty|(function).*?(?=\\\\\\()| for .+?(?=\\\\\\])/g, '$1.*?') + '$'\n);\n\n/** Built-in value references. */\nvar Buffer = moduleExports ? root.Buffer : undefined,\n    Symbol = root.Symbol,\n    Uint8Array = root.Uint8Array,\n    allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined,\n    getPrototype = overArg(Object.getPrototypeOf, Object),\n    objectCreate = Object.create,\n    propertyIsEnumerable = objectProto.propertyIsEnumerable,\n    splice = arrayProto.splice,\n    symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\nvar defineProperty = (function() {\n  try {\n    var func = getNative(Object, 'defineProperty');\n    func({}, '', {});\n    return func;\n  } catch (e) {}\n}());\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined,\n    nativeMax = Math.max,\n    nativeNow = Date.now;\n\n/* Built-in method references that are verified to be native. */\nvar Map = getNative(root, 'Map'),\n    nativeCreate = getNative(Object, 'create');\n\n/**\n * The base implementation of `_.create` without support for assigning\n * properties to the created object.\n *\n * @private\n * @param {Object} proto The object to inherit from.\n * @returns {Object} Returns the new object.\n */\nvar baseCreate = (function() {\n  function object() {}\n  return function(proto) {\n    if (!isObject(proto)) {\n      return {};\n    }\n    if (objectCreate) {\n      return objectCreate(proto);\n    }\n    object.prototype = proto;\n    var result = new object;\n    object.prototype = undefined;\n    return result;\n  };\n}());\n\n/**\n * Creates a hash object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Hash(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n/**\n * Removes all key-value entries from the hash.\n *\n * @private\n * @name clear\n * @memberOf Hash\n */\nfunction hashClear() {\n  this.__data__ = nativeCreate ? nativeCreate(null) : {};\n  this.size = 0;\n}\n\n/**\n * Removes `key` and its value from the hash.\n *\n * @private\n * @name delete\n * @memberOf Hash\n * @param {Object} hash The hash to modify.\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction hashDelete(key) {\n  var result = this.has(key) && delete this.__data__[key];\n  this.size -= result ? 1 : 0;\n  return result;\n}\n\n/**\n * Gets the hash value for `key`.\n *\n * @private\n * @name get\n * @memberOf Hash\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction hashGet(key) {\n  var data = this.__data__;\n  if (nativeCreate) {\n    var result = data[key];\n    return result === HASH_UNDEFINED ? undefined : result;\n  }\n  return hasOwnProperty.call(data, key) ? data[key] : undefined;\n}\n\n/**\n * Checks if a hash value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Hash\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction hashHas(key) {\n  var data = this.__data__;\n  return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key);\n}\n\n/**\n * Sets the hash `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Hash\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the hash instance.\n */\nfunction hashSet(key, value) {\n  var data = this.__data__;\n  this.size += this.has(key) ? 0 : 1;\n  data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;\n  return this;\n}\n\n// Add methods to `Hash`.\nHash.prototype.clear = hashClear;\nHash.prototype['delete'] = hashDelete;\nHash.prototype.get = hashGet;\nHash.prototype.has = hashHas;\nHash.prototype.set = hashSet;\n\n/**\n * Creates an list cache object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction ListCache(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n/**\n * Removes all key-value entries from the list cache.\n *\n * @private\n * @name clear\n * @memberOf ListCache\n */\nfunction listCacheClear() {\n  this.__data__ = [];\n  this.size = 0;\n}\n\n/**\n * Removes `key` and its value from the list cache.\n *\n * @private\n * @name delete\n * @memberOf ListCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction listCacheDelete(key) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  if (index < 0) {\n    return false;\n  }\n  var lastIndex = data.length - 1;\n  if (index == lastIndex) {\n    data.pop();\n  } else {\n    splice.call(data, index, 1);\n  }\n  --this.size;\n  return true;\n}\n\n/**\n * Gets the list cache value for `key`.\n *\n * @private\n * @name get\n * @memberOf ListCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction listCacheGet(key) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  return index < 0 ? undefined : data[index][1];\n}\n\n/**\n * Checks if a list cache value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf ListCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction listCacheHas(key) {\n  return assocIndexOf(this.__data__, key) > -1;\n}\n\n/**\n * Sets the list cache `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf ListCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the list cache instance.\n */\nfunction listCacheSet(key, value) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  if (index < 0) {\n    ++this.size;\n    data.push([key, value]);\n  } else {\n    data[index][1] = value;\n  }\n  return this;\n}\n\n// Add methods to `ListCache`.\nListCache.prototype.clear = listCacheClear;\nListCache.prototype['delete'] = listCacheDelete;\nListCache.prototype.get = listCacheGet;\nListCache.prototype.has = listCacheHas;\nListCache.prototype.set = listCacheSet;\n\n/**\n * Creates a map cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction MapCache(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n/**\n * Removes all key-value entries from the map.\n *\n * @private\n * @name clear\n * @memberOf MapCache\n */\nfunction mapCacheClear() {\n  this.size = 0;\n  this.__data__ = {\n    'hash': new Hash,\n    'map': new (Map || ListCache),\n    'string': new Hash\n  };\n}\n\n/**\n * Removes `key` and its value from the map.\n *\n * @private\n * @name delete\n * @memberOf MapCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction mapCacheDelete(key) {\n  var result = getMapData(this, key)['delete'](key);\n  this.size -= result ? 1 : 0;\n  return result;\n}\n\n/**\n * Gets the map value for `key`.\n *\n * @private\n * @name get\n * @memberOf MapCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction mapCacheGet(key) {\n  return getMapData(this, key).get(key);\n}\n\n/**\n * Checks if a map value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf MapCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction mapCacheHas(key) {\n  return getMapData(this, key).has(key);\n}\n\n/**\n * Sets the map `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf MapCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the map cache instance.\n */\nfunction mapCacheSet(key, value) {\n  var data = getMapData(this, key),\n      size = data.size;\n\n  data.set(key, value);\n  this.size += data.size == size ? 0 : 1;\n  return this;\n}\n\n// Add methods to `MapCache`.\nMapCache.prototype.clear = mapCacheClear;\nMapCache.prototype['delete'] = mapCacheDelete;\nMapCache.prototype.get = mapCacheGet;\nMapCache.prototype.has = mapCacheHas;\nMapCache.prototype.set = mapCacheSet;\n\n/**\n * Creates a stack cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Stack(entries) {\n  var data = this.__data__ = new ListCache(entries);\n  this.size = data.size;\n}\n\n/**\n * Removes all key-value entries from the stack.\n *\n * @private\n * @name clear\n * @memberOf Stack\n */\nfunction stackClear() {\n  this.__data__ = new ListCache;\n  this.size = 0;\n}\n\n/**\n * Removes `key` and its value from the stack.\n *\n * @private\n * @name delete\n * @memberOf Stack\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction stackDelete(key) {\n  var data = this.__data__,\n      result = data['delete'](key);\n\n  this.size = data.size;\n  return result;\n}\n\n/**\n * Gets the stack value for `key`.\n *\n * @private\n * @name get\n * @memberOf Stack\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction stackGet(key) {\n  return this.__data__.get(key);\n}\n\n/**\n * Checks if a stack value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Stack\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction stackHas(key) {\n  return this.__data__.has(key);\n}\n\n/**\n * Sets the stack `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Stack\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the stack cache instance.\n */\nfunction stackSet(key, value) {\n  var data = this.__data__;\n  if (data instanceof ListCache) {\n    var pairs = data.__data__;\n    if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {\n      pairs.push([key, value]);\n      this.size = ++data.size;\n      return this;\n    }\n    data = this.__data__ = new MapCache(pairs);\n  }\n  data.set(key, value);\n  this.size = data.size;\n  return this;\n}\n\n// Add methods to `Stack`.\nStack.prototype.clear = stackClear;\nStack.prototype['delete'] = stackDelete;\nStack.prototype.get = stackGet;\nStack.prototype.has = stackHas;\nStack.prototype.set = stackSet;\n\n/**\n * Creates an array of the enumerable property names of the array-like `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @param {boolean} inherited Specify returning inherited property names.\n * @returns {Array} Returns the array of property names.\n */\nfunction arrayLikeKeys(value, inherited) {\n  var isArr = isArray(value),\n      isArg = !isArr && isArguments(value),\n      isBuff = !isArr && !isArg && isBuffer(value),\n      isType = !isArr && !isArg && !isBuff && isTypedArray(value),\n      skipIndexes = isArr || isArg || isBuff || isType,\n      result = skipIndexes ? baseTimes(value.length, String) : [],\n      length = result.length;\n\n  for (var key in value) {\n    if ((inherited || hasOwnProperty.call(value, key)) &&\n        !(skipIndexes && (\n           // Safari 9 has enumerable `arguments.length` in strict mode.\n           key == 'length' ||\n           // Node.js 0.10 has enumerable non-index properties on buffers.\n           (isBuff && (key == 'offset' || key == 'parent')) ||\n           // PhantomJS 2 has enumerable non-index properties on typed arrays.\n           (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||\n           // Skip index properties.\n           isIndex(key, length)\n        ))) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\n/**\n * This function is like `assignValue` except that it doesn't assign\n * `undefined` values.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction assignMergeValue(object, key, value) {\n  if ((value !== undefined && !eq(object[key], value)) ||\n      (value === undefined && !(key in object))) {\n    baseAssignValue(object, key, value);\n  }\n}\n\n/**\n * Assigns `value` to `key` of `object` if the existing value is not equivalent\n * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * for equality comparisons.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction assignValue(object, key, value) {\n  var objValue = object[key];\n  if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||\n      (value === undefined && !(key in object))) {\n    baseAssignValue(object, key, value);\n  }\n}\n\n/**\n * Gets the index at which the `key` is found in `array` of key-value pairs.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {*} key The key to search for.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\nfunction assocIndexOf(array, key) {\n  var length = array.length;\n  while (length--) {\n    if (eq(array[length][0], key)) {\n      return length;\n    }\n  }\n  return -1;\n}\n\n/**\n * The base implementation of `assignValue` and `assignMergeValue` without\n * value checks.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction baseAssignValue(object, key, value) {\n  if (key == '__proto__' && defineProperty) {\n    defineProperty(object, key, {\n      'configurable': true,\n      'enumerable': true,\n      'value': value,\n      'writable': true\n    });\n  } else {\n    object[key] = value;\n  }\n}\n\n/**\n * The base implementation of `baseForOwn` which iterates over `object`\n * properties returned by `keysFunc` and invokes `iteratee` for each property.\n * Iteratee functions may exit iteration early by explicitly returning `false`.\n *\n * @private\n * @param {Object} object The object to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @param {Function} keysFunc The function to get the keys of `object`.\n * @returns {Object} Returns `object`.\n */\nvar baseFor = createBaseFor();\n\n/**\n * The base implementation of `getTag` without fallbacks for buggy environments.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nfunction baseGetTag(value) {\n  if (value == null) {\n    return value === undefined ? undefinedTag : nullTag;\n  }\n  return (symToStringTag && symToStringTag in Object(value))\n    ? getRawTag(value)\n    : objectToString(value);\n}\n\n/**\n * The base implementation of `_.isArguments`.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n */\nfunction baseIsArguments(value) {\n  return isObjectLike(value) && baseGetTag(value) == argsTag;\n}\n\n/**\n * The base implementation of `_.isNative` without bad shim checks.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a native function,\n *  else `false`.\n */\nfunction baseIsNative(value) {\n  if (!isObject(value) || isMasked(value)) {\n    return false;\n  }\n  var pattern = isFunction(value) ? reIsNative : reIsHostCtor;\n  return pattern.test(toSource(value));\n}\n\n/**\n * The base implementation of `_.isTypedArray` without Node.js optimizations.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n */\nfunction baseIsTypedArray(value) {\n  return isObjectLike(value) &&\n    isLength(value.length) && !!typedArrayTags[baseGetTag(value)];\n}\n\n/**\n * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction baseKeysIn(object) {\n  if (!isObject(object)) {\n    return nativeKeysIn(object);\n  }\n  var isProto = isPrototype(object),\n      result = [];\n\n  for (var key in object) {\n    if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\n/**\n * The base implementation of `_.merge` without support for multiple sources.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @param {number} srcIndex The index of `source`.\n * @param {Function} [customizer] The function to customize merged values.\n * @param {Object} [stack] Tracks traversed source values and their merged\n *  counterparts.\n */\nfunction baseMerge(object, source, srcIndex, customizer, stack) {\n  if (object === source) {\n    return;\n  }\n  baseFor(source, function(srcValue, key) {\n    stack || (stack = new Stack);\n    if (isObject(srcValue)) {\n      baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);\n    }\n    else {\n      var newValue = customizer\n        ? customizer(safeGet(object, key), srcValue, (key + ''), object, source, stack)\n        : undefined;\n\n      if (newValue === undefined) {\n        newValue = srcValue;\n      }\n      assignMergeValue(object, key, newValue);\n    }\n  }, keysIn);\n}\n\n/**\n * A specialized version of `baseMerge` for arrays and objects which performs\n * deep merges and tracks traversed objects enabling objects with circular\n * references to be merged.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @param {string} key The key of the value to merge.\n * @param {number} srcIndex The index of `source`.\n * @param {Function} mergeFunc The function to merge values.\n * @param {Function} [customizer] The function to customize assigned values.\n * @param {Object} [stack] Tracks traversed source values and their merged\n *  counterparts.\n */\nfunction baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {\n  var objValue = safeGet(object, key),\n      srcValue = safeGet(source, key),\n      stacked = stack.get(srcValue);\n\n  if (stacked) {\n    assignMergeValue(object, key, stacked);\n    return;\n  }\n  var newValue = customizer\n    ? customizer(objValue, srcValue, (key + ''), object, source, stack)\n    : undefined;\n\n  var isCommon = newValue === undefined;\n\n  if (isCommon) {\n    var isArr = isArray(srcValue),\n        isBuff = !isArr && isBuffer(srcValue),\n        isTyped = !isArr && !isBuff && isTypedArray(srcValue);\n\n    newValue = srcValue;\n    if (isArr || isBuff || isTyped) {\n      if (isArray(objValue)) {\n        newValue = objValue;\n      }\n      else if (isArrayLikeObject(objValue)) {\n        newValue = copyArray(objValue);\n      }\n      else if (isBuff) {\n        isCommon = false;\n        newValue = cloneBuffer(srcValue, true);\n      }\n      else if (isTyped) {\n        isCommon = false;\n        newValue = cloneTypedArray(srcValue, true);\n      }\n      else {\n        newValue = [];\n      }\n    }\n    else if (isPlainObject(srcValue) || isArguments(srcValue)) {\n      newValue = objValue;\n      if (isArguments(objValue)) {\n        newValue = toPlainObject(objValue);\n      }\n      else if (!isObject(objValue) || isFunction(objValue)) {\n        newValue = initCloneObject(srcValue);\n      }\n    }\n    else {\n      isCommon = false;\n    }\n  }\n  if (isCommon) {\n    // Recursively merge objects and arrays (susceptible to call stack limits).\n    stack.set(srcValue, newValue);\n    mergeFunc(newValue, srcValue, srcIndex, customizer, stack);\n    stack['delete'](srcValue);\n  }\n  assignMergeValue(object, key, newValue);\n}\n\n/**\n * The base implementation of `_.rest` which doesn't validate or coerce arguments.\n *\n * @private\n * @param {Function} func The function to apply a rest parameter to.\n * @param {number} [start=func.length-1] The start position of the rest parameter.\n * @returns {Function} Returns the new function.\n */\nfunction baseRest(func, start) {\n  return setToString(overRest(func, start, identity), func + '');\n}\n\n/**\n * The base implementation of `setToString` without support for hot loop shorting.\n *\n * @private\n * @param {Function} func The function to modify.\n * @param {Function} string The `toString` result.\n * @returns {Function} Returns `func`.\n */\nvar baseSetToString = !defineProperty ? identity : function(func, string) {\n  return defineProperty(func, 'toString', {\n    'configurable': true,\n    'enumerable': false,\n    'value': constant(string),\n    'writable': true\n  });\n};\n\n/**\n * Creates a clone of  `buffer`.\n *\n * @private\n * @param {Buffer} buffer The buffer to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Buffer} Returns the cloned buffer.\n */\nfunction cloneBuffer(buffer, isDeep) {\n  if (isDeep) {\n    return buffer.slice();\n  }\n  var length = buffer.length,\n      result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);\n\n  buffer.copy(result);\n  return result;\n}\n\n/**\n * Creates a clone of `arrayBuffer`.\n *\n * @private\n * @param {ArrayBuffer} arrayBuffer The array buffer to clone.\n * @returns {ArrayBuffer} Returns the cloned array buffer.\n */\nfunction cloneArrayBuffer(arrayBuffer) {\n  var result = new arrayBuffer.constructor(arrayBuffer.byteLength);\n  new Uint8Array(result).set(new Uint8Array(arrayBuffer));\n  return result;\n}\n\n/**\n * Creates a clone of `typedArray`.\n *\n * @private\n * @param {Object} typedArray The typed array to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned typed array.\n */\nfunction cloneTypedArray(typedArray, isDeep) {\n  var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;\n  return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);\n}\n\n/**\n * Copies the values of `source` to `array`.\n *\n * @private\n * @param {Array} source The array to copy values from.\n * @param {Array} [array=[]] The array to copy values to.\n * @returns {Array} Returns `array`.\n */\nfunction copyArray(source, array) {\n  var index = -1,\n      length = source.length;\n\n  array || (array = Array(length));\n  while (++index < length) {\n    array[index] = source[index];\n  }\n  return array;\n}\n\n/**\n * Copies properties of `source` to `object`.\n *\n * @private\n * @param {Object} source The object to copy properties from.\n * @param {Array} props The property identifiers to copy.\n * @param {Object} [object={}] The object to copy properties to.\n * @param {Function} [customizer] The function to customize copied values.\n * @returns {Object} Returns `object`.\n */\nfunction copyObject(source, props, object, customizer) {\n  var isNew = !object;\n  object || (object = {});\n\n  var index = -1,\n      length = props.length;\n\n  while (++index < length) {\n    var key = props[index];\n\n    var newValue = customizer\n      ? customizer(object[key], source[key], key, object, source)\n      : undefined;\n\n    if (newValue === undefined) {\n      newValue = source[key];\n    }\n    if (isNew) {\n      baseAssignValue(object, key, newValue);\n    } else {\n      assignValue(object, key, newValue);\n    }\n  }\n  return object;\n}\n\n/**\n * Creates a function like `_.assign`.\n *\n * @private\n * @param {Function} assigner The function to assign values.\n * @returns {Function} Returns the new assigner function.\n */\nfunction createAssigner(assigner) {\n  return baseRest(function(object, sources) {\n    var index = -1,\n        length = sources.length,\n        customizer = length > 1 ? sources[length - 1] : undefined,\n        guard = length > 2 ? sources[2] : undefined;\n\n    customizer = (assigner.length > 3 && typeof customizer == 'function')\n      ? (length--, customizer)\n      : undefined;\n\n    if (guard && isIterateeCall(sources[0], sources[1], guard)) {\n      customizer = length < 3 ? undefined : customizer;\n      length = 1;\n    }\n    object = Object(object);\n    while (++index < length) {\n      var source = sources[index];\n      if (source) {\n        assigner(object, source, index, customizer);\n      }\n    }\n    return object;\n  });\n}\n\n/**\n * Creates a base function for methods like `_.forIn` and `_.forOwn`.\n *\n * @private\n * @param {boolean} [fromRight] Specify iterating from right to left.\n * @returns {Function} Returns the new base function.\n */\nfunction createBaseFor(fromRight) {\n  return function(object, iteratee, keysFunc) {\n    var index = -1,\n        iterable = Object(object),\n        props = keysFunc(object),\n        length = props.length;\n\n    while (length--) {\n      var key = props[fromRight ? length : ++index];\n      if (iteratee(iterable[key], key, iterable) === false) {\n        break;\n      }\n    }\n    return object;\n  };\n}\n\n/**\n * Gets the data for `map`.\n *\n * @private\n * @param {Object} map The map to query.\n * @param {string} key The reference key.\n * @returns {*} Returns the map data.\n */\nfunction getMapData(map, key) {\n  var data = map.__data__;\n  return isKeyable(key)\n    ? data[typeof key == 'string' ? 'string' : 'hash']\n    : data.map;\n}\n\n/**\n * Gets the native function at `key` of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the method to get.\n * @returns {*} Returns the function if it's native, else `undefined`.\n */\nfunction getNative(object, key) {\n  var value = getValue(object, key);\n  return baseIsNative(value) ? value : undefined;\n}\n\n/**\n * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the raw `toStringTag`.\n */\nfunction getRawTag(value) {\n  var isOwn = hasOwnProperty.call(value, symToStringTag),\n      tag = value[symToStringTag];\n\n  try {\n    value[symToStringTag] = undefined;\n    var unmasked = true;\n  } catch (e) {}\n\n  var result = nativeObjectToString.call(value);\n  if (unmasked) {\n    if (isOwn) {\n      value[symToStringTag] = tag;\n    } else {\n      delete value[symToStringTag];\n    }\n  }\n  return result;\n}\n\n/**\n * Initializes an object clone.\n *\n * @private\n * @param {Object} object The object to clone.\n * @returns {Object} Returns the initialized clone.\n */\nfunction initCloneObject(object) {\n  return (typeof object.constructor == 'function' && !isPrototype(object))\n    ? baseCreate(getPrototype(object))\n    : {};\n}\n\n/**\n * Checks if `value` is a valid array-like index.\n *\n * @private\n * @param {*} value The value to check.\n * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.\n * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.\n */\nfunction isIndex(value, length) {\n  var type = typeof value;\n  length = length == null ? MAX_SAFE_INTEGER : length;\n\n  return !!length &&\n    (type == 'number' ||\n      (type != 'symbol' && reIsUint.test(value))) &&\n        (value > -1 && value % 1 == 0 && value < length);\n}\n\n/**\n * Checks if the given arguments are from an iteratee call.\n *\n * @private\n * @param {*} value The potential iteratee value argument.\n * @param {*} index The potential iteratee index or key argument.\n * @param {*} object The potential iteratee object argument.\n * @returns {boolean} Returns `true` if the arguments are from an iteratee call,\n *  else `false`.\n */\nfunction isIterateeCall(value, index, object) {\n  if (!isObject(object)) {\n    return false;\n  }\n  var type = typeof index;\n  if (type == 'number'\n        ? (isArrayLike(object) && isIndex(index, object.length))\n        : (type == 'string' && index in object)\n      ) {\n    return eq(object[index], value);\n  }\n  return false;\n}\n\n/**\n * Checks if `value` is suitable for use as unique object key.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is suitable, else `false`.\n */\nfunction isKeyable(value) {\n  var type = typeof value;\n  return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')\n    ? (value !== '__proto__')\n    : (value === null);\n}\n\n/**\n * Checks if `func` has its source masked.\n *\n * @private\n * @param {Function} func The function to check.\n * @returns {boolean} Returns `true` if `func` is masked, else `false`.\n */\nfunction isMasked(func) {\n  return !!maskSrcKey && (maskSrcKey in func);\n}\n\n/**\n * Checks if `value` is likely a prototype object.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.\n */\nfunction isPrototype(value) {\n  var Ctor = value && value.constructor,\n      proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;\n\n  return value === proto;\n}\n\n/**\n * This function is like\n * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * except that it includes inherited enumerable properties.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction nativeKeysIn(object) {\n  var result = [];\n  if (object != null) {\n    for (var key in Object(object)) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\n/**\n * Converts `value` to a string using `Object.prototype.toString`.\n *\n * @private\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n */\nfunction objectToString(value) {\n  return nativeObjectToString.call(value);\n}\n\n/**\n * A specialized version of `baseRest` which transforms the rest array.\n *\n * @private\n * @param {Function} func The function to apply a rest parameter to.\n * @param {number} [start=func.length-1] The start position of the rest parameter.\n * @param {Function} transform The rest array transform.\n * @returns {Function} Returns the new function.\n */\nfunction overRest(func, start, transform) {\n  start = nativeMax(start === undefined ? (func.length - 1) : start, 0);\n  return function() {\n    var args = arguments,\n        index = -1,\n        length = nativeMax(args.length - start, 0),\n        array = Array(length);\n\n    while (++index < length) {\n      array[index] = args[start + index];\n    }\n    index = -1;\n    var otherArgs = Array(start + 1);\n    while (++index < start) {\n      otherArgs[index] = args[index];\n    }\n    otherArgs[start] = transform(array);\n    return apply(func, this, otherArgs);\n  };\n}\n\n/**\n * Gets the value at `key`, unless `key` is \"__proto__\" or \"constructor\".\n *\n * @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the property to get.\n * @returns {*} Returns the property value.\n */\nfunction safeGet(object, key) {\n  if (key === 'constructor' && typeof object[key] === 'function') {\n    return;\n  }\n\n  if (key == '__proto__') {\n    return;\n  }\n\n  return object[key];\n}\n\n/**\n * Sets the `toString` method of `func` to return `string`.\n *\n * @private\n * @param {Function} func The function to modify.\n * @param {Function} string The `toString` result.\n * @returns {Function} Returns `func`.\n */\nvar setToString = shortOut(baseSetToString);\n\n/**\n * Creates a function that'll short out and invoke `identity` instead\n * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN`\n * milliseconds.\n *\n * @private\n * @param {Function} func The function to restrict.\n * @returns {Function} Returns the new shortable function.\n */\nfunction shortOut(func) {\n  var count = 0,\n      lastCalled = 0;\n\n  return function() {\n    var stamp = nativeNow(),\n        remaining = HOT_SPAN - (stamp - lastCalled);\n\n    lastCalled = stamp;\n    if (remaining > 0) {\n      if (++count >= HOT_COUNT) {\n        return arguments[0];\n      }\n    } else {\n      count = 0;\n    }\n    return func.apply(undefined, arguments);\n  };\n}\n\n/**\n * Converts `func` to its source code.\n *\n * @private\n * @param {Function} func The function to convert.\n * @returns {string} Returns the source code.\n */\nfunction toSource(func) {\n  if (func != null) {\n    try {\n      return funcToString.call(func);\n    } catch (e) {}\n    try {\n      return (func + '');\n    } catch (e) {}\n  }\n  return '';\n}\n\n/**\n * Performs a\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * comparison between two values to determine if they are equivalent.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * var object = { 'a': 1 };\n * var other = { 'a': 1 };\n *\n * _.eq(object, object);\n * // => true\n *\n * _.eq(object, other);\n * // => false\n *\n * _.eq('a', 'a');\n * // => true\n *\n * _.eq('a', Object('a'));\n * // => false\n *\n * _.eq(NaN, NaN);\n * // => true\n */\nfunction eq(value, other) {\n  return value === other || (value !== value && other !== other);\n}\n\n/**\n * Checks if `value` is likely an `arguments` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n *  else `false`.\n * @example\n *\n * _.isArguments(function() { return arguments; }());\n * // => true\n *\n * _.isArguments([1, 2, 3]);\n * // => false\n */\nvar isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {\n  return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&\n    !propertyIsEnumerable.call(value, 'callee');\n};\n\n/**\n * Checks if `value` is classified as an `Array` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array, else `false`.\n * @example\n *\n * _.isArray([1, 2, 3]);\n * // => true\n *\n * _.isArray(document.body.children);\n * // => false\n *\n * _.isArray('abc');\n * // => false\n *\n * _.isArray(_.noop);\n * // => false\n */\nvar isArray = Array.isArray;\n\n/**\n * Checks if `value` is array-like. A value is considered array-like if it's\n * not a function and has a `value.length` that's an integer greater than or\n * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n * @example\n *\n * _.isArrayLike([1, 2, 3]);\n * // => true\n *\n * _.isArrayLike(document.body.children);\n * // => true\n *\n * _.isArrayLike('abc');\n * // => true\n *\n * _.isArrayLike(_.noop);\n * // => false\n */\nfunction isArrayLike(value) {\n  return value != null && isLength(value.length) && !isFunction(value);\n}\n\n/**\n * This method is like `_.isArrayLike` except that it also checks if `value`\n * is an object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array-like object,\n *  else `false`.\n * @example\n *\n * _.isArrayLikeObject([1, 2, 3]);\n * // => true\n *\n * _.isArrayLikeObject(document.body.children);\n * // => true\n *\n * _.isArrayLikeObject('abc');\n * // => false\n *\n * _.isArrayLikeObject(_.noop);\n * // => false\n */\nfunction isArrayLikeObject(value) {\n  return isObjectLike(value) && isArrayLike(value);\n}\n\n/**\n * Checks if `value` is a buffer.\n *\n * @static\n * @memberOf _\n * @since 4.3.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.\n * @example\n *\n * _.isBuffer(new Buffer(2));\n * // => true\n *\n * _.isBuffer(new Uint8Array(2));\n * // => false\n */\nvar isBuffer = nativeIsBuffer || stubFalse;\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a function, else `false`.\n * @example\n *\n * _.isFunction(_);\n * // => true\n *\n * _.isFunction(/abc/);\n * // => false\n */\nfunction isFunction(value) {\n  if (!isObject(value)) {\n    return false;\n  }\n  // The use of `Object#toString` avoids issues with the `typeof` operator\n  // in Safari 9 which returns 'object' for typed arrays and other constructors.\n  var tag = baseGetTag(value);\n  return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;\n}\n\n/**\n * Checks if `value` is a valid array-like length.\n *\n * **Note:** This method is loosely based on\n * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n * @example\n *\n * _.isLength(3);\n * // => true\n *\n * _.isLength(Number.MIN_VALUE);\n * // => false\n *\n * _.isLength(Infinity);\n * // => false\n *\n * _.isLength('3');\n * // => false\n */\nfunction isLength(value) {\n  return typeof value == 'number' &&\n    value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n}\n\n/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return value != null && (type == 'object' || type == 'function');\n}\n\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return value != null && typeof value == 'object';\n}\n\n/**\n * Checks if `value` is a plain object, that is, an object created by the\n * `Object` constructor or one with a `[[Prototype]]` of `null`.\n *\n * @static\n * @memberOf _\n * @since 0.8.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n * }\n *\n * _.isPlainObject(new Foo);\n * // => false\n *\n * _.isPlainObject([1, 2, 3]);\n * // => false\n *\n * _.isPlainObject({ 'x': 0, 'y': 0 });\n * // => true\n *\n * _.isPlainObject(Object.create(null));\n * // => true\n */\nfunction isPlainObject(value) {\n  if (!isObjectLike(value) || baseGetTag(value) != objectTag) {\n    return false;\n  }\n  var proto = getPrototype(value);\n  if (proto === null) {\n    return true;\n  }\n  var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;\n  return typeof Ctor == 'function' && Ctor instanceof Ctor &&\n    funcToString.call(Ctor) == objectCtorString;\n}\n\n/**\n * Checks if `value` is classified as a typed array.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n * @example\n *\n * _.isTypedArray(new Uint8Array);\n * // => true\n *\n * _.isTypedArray([]);\n * // => false\n */\nvar isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;\n\n/**\n * Converts `value` to a plain object flattening inherited enumerable string\n * keyed properties of `value` to own properties of the plain object.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {Object} Returns the converted plain object.\n * @example\n *\n * function Foo() {\n *   this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.assign({ 'a': 1 }, new Foo);\n * // => { 'a': 1, 'b': 2 }\n *\n * _.assign({ 'a': 1 }, _.toPlainObject(new Foo));\n * // => { 'a': 1, 'b': 2, 'c': 3 }\n */\nfunction toPlainObject(value) {\n  return copyObject(value, keysIn(value));\n}\n\n/**\n * Creates an array of the own and inherited enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n *   this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keysIn(new Foo);\n * // => ['a', 'b', 'c'] (iteration order is not guaranteed)\n */\nfunction keysIn(object) {\n  return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);\n}\n\n/**\n * This method is like `_.assign` except that it recursively merges own and\n * inherited enumerable string keyed properties of source objects into the\n * destination object. Source properties that resolve to `undefined` are\n * skipped if a destination value exists. Array and plain object properties\n * are merged recursively. Other objects and value types are overridden by\n * assignment. Source objects are applied from left to right. Subsequent\n * sources overwrite property assignments of previous sources.\n *\n * **Note:** This method mutates `object`.\n *\n * @static\n * @memberOf _\n * @since 0.5.0\n * @category Object\n * @param {Object} object The destination object.\n * @param {...Object} [sources] The source objects.\n * @returns {Object} Returns `object`.\n * @example\n *\n * var object = {\n *   'a': [{ 'b': 2 }, { 'd': 4 }]\n * };\n *\n * var other = {\n *   'a': [{ 'c': 3 }, { 'e': 5 }]\n * };\n *\n * _.merge(object, other);\n * // => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] }\n */\nvar merge = createAssigner(function(object, source, srcIndex) {\n  baseMerge(object, source, srcIndex);\n});\n\n/**\n * Creates a function that returns `value`.\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Util\n * @param {*} value The value to return from the new function.\n * @returns {Function} Returns the new constant function.\n * @example\n *\n * var objects = _.times(2, _.constant({ 'a': 1 }));\n *\n * console.log(objects);\n * // => [{ 'a': 1 }, { 'a': 1 }]\n *\n * console.log(objects[0] === objects[1]);\n * // => true\n */\nfunction constant(value) {\n  return function() {\n    return value;\n  };\n}\n\n/**\n * This method returns the first argument it receives.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Util\n * @param {*} value Any value.\n * @returns {*} Returns `value`.\n * @example\n *\n * var object = { 'a': 1 };\n *\n * console.log(_.identity(object) === object);\n * // => true\n */\nfunction identity(value) {\n  return value;\n}\n\n/**\n * This method returns `false`.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {boolean} Returns `false`.\n * @example\n *\n * _.times(2, _.stubFalse);\n * // => [false, false]\n */\nfunction stubFalse() {\n  return false;\n}\n\nmodule.exports = merge;\n","/**\n * Lodash (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright OpenJS Foundation and other contributors <https://openjsf.org/>\n * Released under MIT license <https://lodash.com/license>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n */\n\n/** Used as the size to enable large array optimizations. */\nvar LARGE_ARRAY_SIZE = 200;\n\n/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/** Used to detect hot functions by number of calls within a span of milliseconds. */\nvar HOT_COUNT = 800,\n    HOT_SPAN = 16;\n\n/** Used as references for various `Number` constants. */\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]',\n    arrayTag = '[object Array]',\n    asyncTag = '[object AsyncFunction]',\n    boolTag = '[object Boolean]',\n    dateTag = '[object Date]',\n    errorTag = '[object Error]',\n    funcTag = '[object Function]',\n    genTag = '[object GeneratorFunction]',\n    mapTag = '[object Map]',\n    numberTag = '[object Number]',\n    nullTag = '[object Null]',\n    objectTag = '[object Object]',\n    proxyTag = '[object Proxy]',\n    regexpTag = '[object RegExp]',\n    setTag = '[object Set]',\n    stringTag = '[object String]',\n    undefinedTag = '[object Undefined]',\n    weakMapTag = '[object WeakMap]';\n\nvar arrayBufferTag = '[object ArrayBuffer]',\n    dataViewTag = '[object DataView]',\n    float32Tag = '[object Float32Array]',\n    float64Tag = '[object Float64Array]',\n    int8Tag = '[object Int8Array]',\n    int16Tag = '[object Int16Array]',\n    int32Tag = '[object Int32Array]',\n    uint8Tag = '[object Uint8Array]',\n    uint8ClampedTag = '[object Uint8ClampedArray]',\n    uint16Tag = '[object Uint16Array]',\n    uint32Tag = '[object Uint32Array]';\n\n/**\n * Used to match `RegExp`\n * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).\n */\nvar reRegExpChar = /[\\\\^$.*+?()[\\]{}|]/g;\n\n/** Used to detect host constructors (Safari). */\nvar reIsHostCtor = /^\\[object .+?Constructor\\]$/;\n\n/** Used to detect unsigned integer values. */\nvar reIsUint = /^(?:0|[1-9]\\d*)$/;\n\n/** Used to identify `toStringTag` values of typed arrays. */\nvar typedArrayTags = {};\ntypedArrayTags[float32Tag] = typedArrayTags[float64Tag] =\ntypedArrayTags[int8Tag] = typedArrayTags[int16Tag] =\ntypedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =\ntypedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =\ntypedArrayTags[uint32Tag] = true;\ntypedArrayTags[argsTag] = typedArrayTags[arrayTag] =\ntypedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =\ntypedArrayTags[dataViewTag] = typedArrayTags[dateTag] =\ntypedArrayTags[errorTag] = typedArrayTags[funcTag] =\ntypedArrayTags[mapTag] = typedArrayTags[numberTag] =\ntypedArrayTags[objectTag] = typedArrayTags[regexpTag] =\ntypedArrayTags[setTag] = typedArrayTags[stringTag] =\ntypedArrayTags[weakMapTag] = false;\n\n/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\n/** Detect free variable `exports`. */\nvar freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/** Detect free variable `process` from Node.js. */\nvar freeProcess = moduleExports && freeGlobal.process;\n\n/** Used to access faster Node.js helpers. */\nvar nodeUtil = (function() {\n  try {\n    // Use `util.types` for Node.js 10+.\n    var types = freeModule && freeModule.require && freeModule.require('util').types;\n\n    if (types) {\n      return types;\n    }\n\n    // Legacy `process.binding('util')` for Node.js < 10.\n    return freeProcess && freeProcess.binding && freeProcess.binding('util');\n  } catch (e) {}\n}());\n\n/* Node.js helper references. */\nvar nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;\n\n/**\n * A faster alternative to `Function#apply`, this function invokes `func`\n * with the `this` binding of `thisArg` and the arguments of `args`.\n *\n * @private\n * @param {Function} func The function to invoke.\n * @param {*} thisArg The `this` binding of `func`.\n * @param {Array} args The arguments to invoke `func` with.\n * @returns {*} Returns the result of `func`.\n */\nfunction apply(func, thisArg, args) {\n  switch (args.length) {\n    case 0: return func.call(thisArg);\n    case 1: return func.call(thisArg, args[0]);\n    case 2: return func.call(thisArg, args[0], args[1]);\n    case 3: return func.call(thisArg, args[0], args[1], args[2]);\n  }\n  return func.apply(thisArg, args);\n}\n\n/**\n * The base implementation of `_.times` without support for iteratee shorthands\n * or max array length checks.\n *\n * @private\n * @param {number} n The number of times to invoke `iteratee`.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the array of results.\n */\nfunction baseTimes(n, iteratee) {\n  var index = -1,\n      result = Array(n);\n\n  while (++index < n) {\n    result[index] = iteratee(index);\n  }\n  return result;\n}\n\n/**\n * The base implementation of `_.unary` without support for storing metadata.\n *\n * @private\n * @param {Function} func The function to cap arguments for.\n * @returns {Function} Returns the new capped function.\n */\nfunction baseUnary(func) {\n  return function(value) {\n    return func(value);\n  };\n}\n\n/**\n * Gets the value at `key` of `object`.\n *\n * @private\n * @param {Object} [object] The object to query.\n * @param {string} key The key of the property to get.\n * @returns {*} Returns the property value.\n */\nfunction getValue(object, key) {\n  return object == null ? undefined : object[key];\n}\n\n/**\n * Creates a unary function that invokes `func` with its argument transformed.\n *\n * @private\n * @param {Function} func The function to wrap.\n * @param {Function} transform The argument transform.\n * @returns {Function} Returns the new function.\n */\nfunction overArg(func, transform) {\n  return function(arg) {\n    return func(transform(arg));\n  };\n}\n\n/** Used for built-in method references. */\nvar arrayProto = Array.prototype,\n    funcProto = Function.prototype,\n    objectProto = Object.prototype;\n\n/** Used to detect overreaching core-js shims. */\nvar coreJsData = root['__core-js_shared__'];\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Used to detect methods masquerading as native. */\nvar maskSrcKey = (function() {\n  var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');\n  return uid ? ('Symbol(src)_1.' + uid) : '';\n}());\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/** Used to infer the `Object` constructor. */\nvar objectCtorString = funcToString.call(Object);\n\n/** Used to detect if a method is native. */\nvar reIsNative = RegExp('^' +\n  funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\\\$&')\n  .replace(/hasOwnProperty|(function).*?(?=\\\\\\()| for .+?(?=\\\\\\])/g, '$1.*?') + '$'\n);\n\n/** Built-in value references. */\nvar Buffer = moduleExports ? root.Buffer : undefined,\n    Symbol = root.Symbol,\n    Uint8Array = root.Uint8Array,\n    allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined,\n    getPrototype = overArg(Object.getPrototypeOf, Object),\n    objectCreate = Object.create,\n    propertyIsEnumerable = objectProto.propertyIsEnumerable,\n    splice = arrayProto.splice,\n    symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\nvar defineProperty = (function() {\n  try {\n    var func = getNative(Object, 'defineProperty');\n    func({}, '', {});\n    return func;\n  } catch (e) {}\n}());\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined,\n    nativeMax = Math.max,\n    nativeNow = Date.now;\n\n/* Built-in method references that are verified to be native. */\nvar Map = getNative(root, 'Map'),\n    nativeCreate = getNative(Object, 'create');\n\n/**\n * The base implementation of `_.create` without support for assigning\n * properties to the created object.\n *\n * @private\n * @param {Object} proto The object to inherit from.\n * @returns {Object} Returns the new object.\n */\nvar baseCreate = (function() {\n  function object() {}\n  return function(proto) {\n    if (!isObject(proto)) {\n      return {};\n    }\n    if (objectCreate) {\n      return objectCreate(proto);\n    }\n    object.prototype = proto;\n    var result = new object;\n    object.prototype = undefined;\n    return result;\n  };\n}());\n\n/**\n * Creates a hash object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Hash(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n/**\n * Removes all key-value entries from the hash.\n *\n * @private\n * @name clear\n * @memberOf Hash\n */\nfunction hashClear() {\n  this.__data__ = nativeCreate ? nativeCreate(null) : {};\n  this.size = 0;\n}\n\n/**\n * Removes `key` and its value from the hash.\n *\n * @private\n * @name delete\n * @memberOf Hash\n * @param {Object} hash The hash to modify.\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction hashDelete(key) {\n  var result = this.has(key) && delete this.__data__[key];\n  this.size -= result ? 1 : 0;\n  return result;\n}\n\n/**\n * Gets the hash value for `key`.\n *\n * @private\n * @name get\n * @memberOf Hash\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction hashGet(key) {\n  var data = this.__data__;\n  if (nativeCreate) {\n    var result = data[key];\n    return result === HASH_UNDEFINED ? undefined : result;\n  }\n  return hasOwnProperty.call(data, key) ? data[key] : undefined;\n}\n\n/**\n * Checks if a hash value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Hash\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction hashHas(key) {\n  var data = this.__data__;\n  return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key);\n}\n\n/**\n * Sets the hash `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Hash\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the hash instance.\n */\nfunction hashSet(key, value) {\n  var data = this.__data__;\n  this.size += this.has(key) ? 0 : 1;\n  data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;\n  return this;\n}\n\n// Add methods to `Hash`.\nHash.prototype.clear = hashClear;\nHash.prototype['delete'] = hashDelete;\nHash.prototype.get = hashGet;\nHash.prototype.has = hashHas;\nHash.prototype.set = hashSet;\n\n/**\n * Creates an list cache object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction ListCache(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n/**\n * Removes all key-value entries from the list cache.\n *\n * @private\n * @name clear\n * @memberOf ListCache\n */\nfunction listCacheClear() {\n  this.__data__ = [];\n  this.size = 0;\n}\n\n/**\n * Removes `key` and its value from the list cache.\n *\n * @private\n * @name delete\n * @memberOf ListCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction listCacheDelete(key) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  if (index < 0) {\n    return false;\n  }\n  var lastIndex = data.length - 1;\n  if (index == lastIndex) {\n    data.pop();\n  } else {\n    splice.call(data, index, 1);\n  }\n  --this.size;\n  return true;\n}\n\n/**\n * Gets the list cache value for `key`.\n *\n * @private\n * @name get\n * @memberOf ListCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction listCacheGet(key) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  return index < 0 ? undefined : data[index][1];\n}\n\n/**\n * Checks if a list cache value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf ListCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction listCacheHas(key) {\n  return assocIndexOf(this.__data__, key) > -1;\n}\n\n/**\n * Sets the list cache `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf ListCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the list cache instance.\n */\nfunction listCacheSet(key, value) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  if (index < 0) {\n    ++this.size;\n    data.push([key, value]);\n  } else {\n    data[index][1] = value;\n  }\n  return this;\n}\n\n// Add methods to `ListCache`.\nListCache.prototype.clear = listCacheClear;\nListCache.prototype['delete'] = listCacheDelete;\nListCache.prototype.get = listCacheGet;\nListCache.prototype.has = listCacheHas;\nListCache.prototype.set = listCacheSet;\n\n/**\n * Creates a map cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction MapCache(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n/**\n * Removes all key-value entries from the map.\n *\n * @private\n * @name clear\n * @memberOf MapCache\n */\nfunction mapCacheClear() {\n  this.size = 0;\n  this.__data__ = {\n    'hash': new Hash,\n    'map': new (Map || ListCache),\n    'string': new Hash\n  };\n}\n\n/**\n * Removes `key` and its value from the map.\n *\n * @private\n * @name delete\n * @memberOf MapCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction mapCacheDelete(key) {\n  var result = getMapData(this, key)['delete'](key);\n  this.size -= result ? 1 : 0;\n  return result;\n}\n\n/**\n * Gets the map value for `key`.\n *\n * @private\n * @name get\n * @memberOf MapCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction mapCacheGet(key) {\n  return getMapData(this, key).get(key);\n}\n\n/**\n * Checks if a map value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf MapCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction mapCacheHas(key) {\n  return getMapData(this, key).has(key);\n}\n\n/**\n * Sets the map `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf MapCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the map cache instance.\n */\nfunction mapCacheSet(key, value) {\n  var data = getMapData(this, key),\n      size = data.size;\n\n  data.set(key, value);\n  this.size += data.size == size ? 0 : 1;\n  return this;\n}\n\n// Add methods to `MapCache`.\nMapCache.prototype.clear = mapCacheClear;\nMapCache.prototype['delete'] = mapCacheDelete;\nMapCache.prototype.get = mapCacheGet;\nMapCache.prototype.has = mapCacheHas;\nMapCache.prototype.set = mapCacheSet;\n\n/**\n * Creates a stack cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Stack(entries) {\n  var data = this.__data__ = new ListCache(entries);\n  this.size = data.size;\n}\n\n/**\n * Removes all key-value entries from the stack.\n *\n * @private\n * @name clear\n * @memberOf Stack\n */\nfunction stackClear() {\n  this.__data__ = new ListCache;\n  this.size = 0;\n}\n\n/**\n * Removes `key` and its value from the stack.\n *\n * @private\n * @name delete\n * @memberOf Stack\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction stackDelete(key) {\n  var data = this.__data__,\n      result = data['delete'](key);\n\n  this.size = data.size;\n  return result;\n}\n\n/**\n * Gets the stack value for `key`.\n *\n * @private\n * @name get\n * @memberOf Stack\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction stackGet(key) {\n  return this.__data__.get(key);\n}\n\n/**\n * Checks if a stack value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Stack\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction stackHas(key) {\n  return this.__data__.has(key);\n}\n\n/**\n * Sets the stack `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Stack\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the stack cache instance.\n */\nfunction stackSet(key, value) {\n  var data = this.__data__;\n  if (data instanceof ListCache) {\n    var pairs = data.__data__;\n    if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {\n      pairs.push([key, value]);\n      this.size = ++data.size;\n      return this;\n    }\n    data = this.__data__ = new MapCache(pairs);\n  }\n  data.set(key, value);\n  this.size = data.size;\n  return this;\n}\n\n// Add methods to `Stack`.\nStack.prototype.clear = stackClear;\nStack.prototype['delete'] = stackDelete;\nStack.prototype.get = stackGet;\nStack.prototype.has = stackHas;\nStack.prototype.set = stackSet;\n\n/**\n * Creates an array of the enumerable property names of the array-like `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @param {boolean} inherited Specify returning inherited property names.\n * @returns {Array} Returns the array of property names.\n */\nfunction arrayLikeKeys(value, inherited) {\n  var isArr = isArray(value),\n      isArg = !isArr && isArguments(value),\n      isBuff = !isArr && !isArg && isBuffer(value),\n      isType = !isArr && !isArg && !isBuff && isTypedArray(value),\n      skipIndexes = isArr || isArg || isBuff || isType,\n      result = skipIndexes ? baseTimes(value.length, String) : [],\n      length = result.length;\n\n  for (var key in value) {\n    if ((inherited || hasOwnProperty.call(value, key)) &&\n        !(skipIndexes && (\n           // Safari 9 has enumerable `arguments.length` in strict mode.\n           key == 'length' ||\n           // Node.js 0.10 has enumerable non-index properties on buffers.\n           (isBuff && (key == 'offset' || key == 'parent')) ||\n           // PhantomJS 2 has enumerable non-index properties on typed arrays.\n           (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||\n           // Skip index properties.\n           isIndex(key, length)\n        ))) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\n/**\n * This function is like `assignValue` except that it doesn't assign\n * `undefined` values.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction assignMergeValue(object, key, value) {\n  if ((value !== undefined && !eq(object[key], value)) ||\n      (value === undefined && !(key in object))) {\n    baseAssignValue(object, key, value);\n  }\n}\n\n/**\n * Assigns `value` to `key` of `object` if the existing value is not equivalent\n * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * for equality comparisons.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction assignValue(object, key, value) {\n  var objValue = object[key];\n  if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||\n      (value === undefined && !(key in object))) {\n    baseAssignValue(object, key, value);\n  }\n}\n\n/**\n * Gets the index at which the `key` is found in `array` of key-value pairs.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {*} key The key to search for.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\nfunction assocIndexOf(array, key) {\n  var length = array.length;\n  while (length--) {\n    if (eq(array[length][0], key)) {\n      return length;\n    }\n  }\n  return -1;\n}\n\n/**\n * The base implementation of `assignValue` and `assignMergeValue` without\n * value checks.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction baseAssignValue(object, key, value) {\n  if (key == '__proto__' && defineProperty) {\n    defineProperty(object, key, {\n      'configurable': true,\n      'enumerable': true,\n      'value': value,\n      'writable': true\n    });\n  } else {\n    object[key] = value;\n  }\n}\n\n/**\n * The base implementation of `baseForOwn` which iterates over `object`\n * properties returned by `keysFunc` and invokes `iteratee` for each property.\n * Iteratee functions may exit iteration early by explicitly returning `false`.\n *\n * @private\n * @param {Object} object The object to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @param {Function} keysFunc The function to get the keys of `object`.\n * @returns {Object} Returns `object`.\n */\nvar baseFor = createBaseFor();\n\n/**\n * The base implementation of `getTag` without fallbacks for buggy environments.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nfunction baseGetTag(value) {\n  if (value == null) {\n    return value === undefined ? undefinedTag : nullTag;\n  }\n  return (symToStringTag && symToStringTag in Object(value))\n    ? getRawTag(value)\n    : objectToString(value);\n}\n\n/**\n * The base implementation of `_.isArguments`.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n */\nfunction baseIsArguments(value) {\n  return isObjectLike(value) && baseGetTag(value) == argsTag;\n}\n\n/**\n * The base implementation of `_.isNative` without bad shim checks.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a native function,\n *  else `false`.\n */\nfunction baseIsNative(value) {\n  if (!isObject(value) || isMasked(value)) {\n    return false;\n  }\n  var pattern = isFunction(value) ? reIsNative : reIsHostCtor;\n  return pattern.test(toSource(value));\n}\n\n/**\n * The base implementation of `_.isTypedArray` without Node.js optimizations.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n */\nfunction baseIsTypedArray(value) {\n  return isObjectLike(value) &&\n    isLength(value.length) && !!typedArrayTags[baseGetTag(value)];\n}\n\n/**\n * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction baseKeysIn(object) {\n  if (!isObject(object)) {\n    return nativeKeysIn(object);\n  }\n  var isProto = isPrototype(object),\n      result = [];\n\n  for (var key in object) {\n    if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\n/**\n * The base implementation of `_.merge` without support for multiple sources.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @param {number} srcIndex The index of `source`.\n * @param {Function} [customizer] The function to customize merged values.\n * @param {Object} [stack] Tracks traversed source values and their merged\n *  counterparts.\n */\nfunction baseMerge(object, source, srcIndex, customizer, stack) {\n  if (object === source) {\n    return;\n  }\n  baseFor(source, function(srcValue, key) {\n    stack || (stack = new Stack);\n    if (isObject(srcValue)) {\n      baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);\n    }\n    else {\n      var newValue = customizer\n        ? customizer(safeGet(object, key), srcValue, (key + ''), object, source, stack)\n        : undefined;\n\n      if (newValue === undefined) {\n        newValue = srcValue;\n      }\n      assignMergeValue(object, key, newValue);\n    }\n  }, keysIn);\n}\n\n/**\n * A specialized version of `baseMerge` for arrays and objects which performs\n * deep merges and tracks traversed objects enabling objects with circular\n * references to be merged.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @param {string} key The key of the value to merge.\n * @param {number} srcIndex The index of `source`.\n * @param {Function} mergeFunc The function to merge values.\n * @param {Function} [customizer] The function to customize assigned values.\n * @param {Object} [stack] Tracks traversed source values and their merged\n *  counterparts.\n */\nfunction baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {\n  var objValue = safeGet(object, key),\n      srcValue = safeGet(source, key),\n      stacked = stack.get(srcValue);\n\n  if (stacked) {\n    assignMergeValue(object, key, stacked);\n    return;\n  }\n  var newValue = customizer\n    ? customizer(objValue, srcValue, (key + ''), object, source, stack)\n    : undefined;\n\n  var isCommon = newValue === undefined;\n\n  if (isCommon) {\n    var isArr = isArray(srcValue),\n        isBuff = !isArr && isBuffer(srcValue),\n        isTyped = !isArr && !isBuff && isTypedArray(srcValue);\n\n    newValue = srcValue;\n    if (isArr || isBuff || isTyped) {\n      if (isArray(objValue)) {\n        newValue = objValue;\n      }\n      else if (isArrayLikeObject(objValue)) {\n        newValue = copyArray(objValue);\n      }\n      else if (isBuff) {\n        isCommon = false;\n        newValue = cloneBuffer(srcValue, true);\n      }\n      else if (isTyped) {\n        isCommon = false;\n        newValue = cloneTypedArray(srcValue, true);\n      }\n      else {\n        newValue = [];\n      }\n    }\n    else if (isPlainObject(srcValue) || isArguments(srcValue)) {\n      newValue = objValue;\n      if (isArguments(objValue)) {\n        newValue = toPlainObject(objValue);\n      }\n      else if (!isObject(objValue) || isFunction(objValue)) {\n        newValue = initCloneObject(srcValue);\n      }\n    }\n    else {\n      isCommon = false;\n    }\n  }\n  if (isCommon) {\n    // Recursively merge objects and arrays (susceptible to call stack limits).\n    stack.set(srcValue, newValue);\n    mergeFunc(newValue, srcValue, srcIndex, customizer, stack);\n    stack['delete'](srcValue);\n  }\n  assignMergeValue(object, key, newValue);\n}\n\n/**\n * The base implementation of `_.rest` which doesn't validate or coerce arguments.\n *\n * @private\n * @param {Function} func The function to apply a rest parameter to.\n * @param {number} [start=func.length-1] The start position of the rest parameter.\n * @returns {Function} Returns the new function.\n */\nfunction baseRest(func, start) {\n  return setToString(overRest(func, start, identity), func + '');\n}\n\n/**\n * The base implementation of `setToString` without support for hot loop shorting.\n *\n * @private\n * @param {Function} func The function to modify.\n * @param {Function} string The `toString` result.\n * @returns {Function} Returns `func`.\n */\nvar baseSetToString = !defineProperty ? identity : function(func, string) {\n  return defineProperty(func, 'toString', {\n    'configurable': true,\n    'enumerable': false,\n    'value': constant(string),\n    'writable': true\n  });\n};\n\n/**\n * Creates a clone of  `buffer`.\n *\n * @private\n * @param {Buffer} buffer The buffer to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Buffer} Returns the cloned buffer.\n */\nfunction cloneBuffer(buffer, isDeep) {\n  if (isDeep) {\n    return buffer.slice();\n  }\n  var length = buffer.length,\n      result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);\n\n  buffer.copy(result);\n  return result;\n}\n\n/**\n * Creates a clone of `arrayBuffer`.\n *\n * @private\n * @param {ArrayBuffer} arrayBuffer The array buffer to clone.\n * @returns {ArrayBuffer} Returns the cloned array buffer.\n */\nfunction cloneArrayBuffer(arrayBuffer) {\n  var result = new arrayBuffer.constructor(arrayBuffer.byteLength);\n  new Uint8Array(result).set(new Uint8Array(arrayBuffer));\n  return result;\n}\n\n/**\n * Creates a clone of `typedArray`.\n *\n * @private\n * @param {Object} typedArray The typed array to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned typed array.\n */\nfunction cloneTypedArray(typedArray, isDeep) {\n  var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;\n  return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);\n}\n\n/**\n * Copies the values of `source` to `array`.\n *\n * @private\n * @param {Array} source The array to copy values from.\n * @param {Array} [array=[]] The array to copy values to.\n * @returns {Array} Returns `array`.\n */\nfunction copyArray(source, array) {\n  var index = -1,\n      length = source.length;\n\n  array || (array = Array(length));\n  while (++index < length) {\n    array[index] = source[index];\n  }\n  return array;\n}\n\n/**\n * Copies properties of `source` to `object`.\n *\n * @private\n * @param {Object} source The object to copy properties from.\n * @param {Array} props The property identifiers to copy.\n * @param {Object} [object={}] The object to copy properties to.\n * @param {Function} [customizer] The function to customize copied values.\n * @returns {Object} Returns `object`.\n */\nfunction copyObject(source, props, object, customizer) {\n  var isNew = !object;\n  object || (object = {});\n\n  var index = -1,\n      length = props.length;\n\n  while (++index < length) {\n    var key = props[index];\n\n    var newValue = customizer\n      ? customizer(object[key], source[key], key, object, source)\n      : undefined;\n\n    if (newValue === undefined) {\n      newValue = source[key];\n    }\n    if (isNew) {\n      baseAssignValue(object, key, newValue);\n    } else {\n      assignValue(object, key, newValue);\n    }\n  }\n  return object;\n}\n\n/**\n * Creates a function like `_.assign`.\n *\n * @private\n * @param {Function} assigner The function to assign values.\n * @returns {Function} Returns the new assigner function.\n */\nfunction createAssigner(assigner) {\n  return baseRest(function(object, sources) {\n    var index = -1,\n        length = sources.length,\n        customizer = length > 1 ? sources[length - 1] : undefined,\n        guard = length > 2 ? sources[2] : undefined;\n\n    customizer = (assigner.length > 3 && typeof customizer == 'function')\n      ? (length--, customizer)\n      : undefined;\n\n    if (guard && isIterateeCall(sources[0], sources[1], guard)) {\n      customizer = length < 3 ? undefined : customizer;\n      length = 1;\n    }\n    object = Object(object);\n    while (++index < length) {\n      var source = sources[index];\n      if (source) {\n        assigner(object, source, index, customizer);\n      }\n    }\n    return object;\n  });\n}\n\n/**\n * Creates a base function for methods like `_.forIn` and `_.forOwn`.\n *\n * @private\n * @param {boolean} [fromRight] Specify iterating from right to left.\n * @returns {Function} Returns the new base function.\n */\nfunction createBaseFor(fromRight) {\n  return function(object, iteratee, keysFunc) {\n    var index = -1,\n        iterable = Object(object),\n        props = keysFunc(object),\n        length = props.length;\n\n    while (length--) {\n      var key = props[fromRight ? length : ++index];\n      if (iteratee(iterable[key], key, iterable) === false) {\n        break;\n      }\n    }\n    return object;\n  };\n}\n\n/**\n * Gets the data for `map`.\n *\n * @private\n * @param {Object} map The map to query.\n * @param {string} key The reference key.\n * @returns {*} Returns the map data.\n */\nfunction getMapData(map, key) {\n  var data = map.__data__;\n  return isKeyable(key)\n    ? data[typeof key == 'string' ? 'string' : 'hash']\n    : data.map;\n}\n\n/**\n * Gets the native function at `key` of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the method to get.\n * @returns {*} Returns the function if it's native, else `undefined`.\n */\nfunction getNative(object, key) {\n  var value = getValue(object, key);\n  return baseIsNative(value) ? value : undefined;\n}\n\n/**\n * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the raw `toStringTag`.\n */\nfunction getRawTag(value) {\n  var isOwn = hasOwnProperty.call(value, symToStringTag),\n      tag = value[symToStringTag];\n\n  try {\n    value[symToStringTag] = undefined;\n    var unmasked = true;\n  } catch (e) {}\n\n  var result = nativeObjectToString.call(value);\n  if (unmasked) {\n    if (isOwn) {\n      value[symToStringTag] = tag;\n    } else {\n      delete value[symToStringTag];\n    }\n  }\n  return result;\n}\n\n/**\n * Initializes an object clone.\n *\n * @private\n * @param {Object} object The object to clone.\n * @returns {Object} Returns the initialized clone.\n */\nfunction initCloneObject(object) {\n  return (typeof object.constructor == 'function' && !isPrototype(object))\n    ? baseCreate(getPrototype(object))\n    : {};\n}\n\n/**\n * Checks if `value` is a valid array-like index.\n *\n * @private\n * @param {*} value The value to check.\n * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.\n * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.\n */\nfunction isIndex(value, length) {\n  var type = typeof value;\n  length = length == null ? MAX_SAFE_INTEGER : length;\n\n  return !!length &&\n    (type == 'number' ||\n      (type != 'symbol' && reIsUint.test(value))) &&\n        (value > -1 && value % 1 == 0 && value < length);\n}\n\n/**\n * Checks if the given arguments are from an iteratee call.\n *\n * @private\n * @param {*} value The potential iteratee value argument.\n * @param {*} index The potential iteratee index or key argument.\n * @param {*} object The potential iteratee object argument.\n * @returns {boolean} Returns `true` if the arguments are from an iteratee call,\n *  else `false`.\n */\nfunction isIterateeCall(value, index, object) {\n  if (!isObject(object)) {\n    return false;\n  }\n  var type = typeof index;\n  if (type == 'number'\n        ? (isArrayLike(object) && isIndex(index, object.length))\n        : (type == 'string' && index in object)\n      ) {\n    return eq(object[index], value);\n  }\n  return false;\n}\n\n/**\n * Checks if `value` is suitable for use as unique object key.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is suitable, else `false`.\n */\nfunction isKeyable(value) {\n  var type = typeof value;\n  return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')\n    ? (value !== '__proto__')\n    : (value === null);\n}\n\n/**\n * Checks if `func` has its source masked.\n *\n * @private\n * @param {Function} func The function to check.\n * @returns {boolean} Returns `true` if `func` is masked, else `false`.\n */\nfunction isMasked(func) {\n  return !!maskSrcKey && (maskSrcKey in func);\n}\n\n/**\n * Checks if `value` is likely a prototype object.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.\n */\nfunction isPrototype(value) {\n  var Ctor = value && value.constructor,\n      proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;\n\n  return value === proto;\n}\n\n/**\n * This function is like\n * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * except that it includes inherited enumerable properties.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction nativeKeysIn(object) {\n  var result = [];\n  if (object != null) {\n    for (var key in Object(object)) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\n/**\n * Converts `value` to a string using `Object.prototype.toString`.\n *\n * @private\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n */\nfunction objectToString(value) {\n  return nativeObjectToString.call(value);\n}\n\n/**\n * A specialized version of `baseRest` which transforms the rest array.\n *\n * @private\n * @param {Function} func The function to apply a rest parameter to.\n * @param {number} [start=func.length-1] The start position of the rest parameter.\n * @param {Function} transform The rest array transform.\n * @returns {Function} Returns the new function.\n */\nfunction overRest(func, start, transform) {\n  start = nativeMax(start === undefined ? (func.length - 1) : start, 0);\n  return function() {\n    var args = arguments,\n        index = -1,\n        length = nativeMax(args.length - start, 0),\n        array = Array(length);\n\n    while (++index < length) {\n      array[index] = args[start + index];\n    }\n    index = -1;\n    var otherArgs = Array(start + 1);\n    while (++index < start) {\n      otherArgs[index] = args[index];\n    }\n    otherArgs[start] = transform(array);\n    return apply(func, this, otherArgs);\n  };\n}\n\n/**\n * Gets the value at `key`, unless `key` is \"__proto__\" or \"constructor\".\n *\n * @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the property to get.\n * @returns {*} Returns the property value.\n */\nfunction safeGet(object, key) {\n  if (key === 'constructor' && typeof object[key] === 'function') {\n    return;\n  }\n\n  if (key == '__proto__') {\n    return;\n  }\n\n  return object[key];\n}\n\n/**\n * Sets the `toString` method of `func` to return `string`.\n *\n * @private\n * @param {Function} func The function to modify.\n * @param {Function} string The `toString` result.\n * @returns {Function} Returns `func`.\n */\nvar setToString = shortOut(baseSetToString);\n\n/**\n * Creates a function that'll short out and invoke `identity` instead\n * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN`\n * milliseconds.\n *\n * @private\n * @param {Function} func The function to restrict.\n * @returns {Function} Returns the new shortable function.\n */\nfunction shortOut(func) {\n  var count = 0,\n      lastCalled = 0;\n\n  return function() {\n    var stamp = nativeNow(),\n        remaining = HOT_SPAN - (stamp - lastCalled);\n\n    lastCalled = stamp;\n    if (remaining > 0) {\n      if (++count >= HOT_COUNT) {\n        return arguments[0];\n      }\n    } else {\n      count = 0;\n    }\n    return func.apply(undefined, arguments);\n  };\n}\n\n/**\n * Converts `func` to its source code.\n *\n * @private\n * @param {Function} func The function to convert.\n * @returns {string} Returns the source code.\n */\nfunction toSource(func) {\n  if (func != null) {\n    try {\n      return funcToString.call(func);\n    } catch (e) {}\n    try {\n      return (func + '');\n    } catch (e) {}\n  }\n  return '';\n}\n\n/**\n * Performs a\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * comparison between two values to determine if they are equivalent.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * var object = { 'a': 1 };\n * var other = { 'a': 1 };\n *\n * _.eq(object, object);\n * // => true\n *\n * _.eq(object, other);\n * // => false\n *\n * _.eq('a', 'a');\n * // => true\n *\n * _.eq('a', Object('a'));\n * // => false\n *\n * _.eq(NaN, NaN);\n * // => true\n */\nfunction eq(value, other) {\n  return value === other || (value !== value && other !== other);\n}\n\n/**\n * Checks if `value` is likely an `arguments` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n *  else `false`.\n * @example\n *\n * _.isArguments(function() { return arguments; }());\n * // => true\n *\n * _.isArguments([1, 2, 3]);\n * // => false\n */\nvar isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {\n  return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&\n    !propertyIsEnumerable.call(value, 'callee');\n};\n\n/**\n * Checks if `value` is classified as an `Array` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array, else `false`.\n * @example\n *\n * _.isArray([1, 2, 3]);\n * // => true\n *\n * _.isArray(document.body.children);\n * // => false\n *\n * _.isArray('abc');\n * // => false\n *\n * _.isArray(_.noop);\n * // => false\n */\nvar isArray = Array.isArray;\n\n/**\n * Checks if `value` is array-like. A value is considered array-like if it's\n * not a function and has a `value.length` that's an integer greater than or\n * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n * @example\n *\n * _.isArrayLike([1, 2, 3]);\n * // => true\n *\n * _.isArrayLike(document.body.children);\n * // => true\n *\n * _.isArrayLike('abc');\n * // => true\n *\n * _.isArrayLike(_.noop);\n * // => false\n */\nfunction isArrayLike(value) {\n  return value != null && isLength(value.length) && !isFunction(value);\n}\n\n/**\n * This method is like `_.isArrayLike` except that it also checks if `value`\n * is an object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array-like object,\n *  else `false`.\n * @example\n *\n * _.isArrayLikeObject([1, 2, 3]);\n * // => true\n *\n * _.isArrayLikeObject(document.body.children);\n * // => true\n *\n * _.isArrayLikeObject('abc');\n * // => false\n *\n * _.isArrayLikeObject(_.noop);\n * // => false\n */\nfunction isArrayLikeObject(value) {\n  return isObjectLike(value) && isArrayLike(value);\n}\n\n/**\n * Checks if `value` is a buffer.\n *\n * @static\n * @memberOf _\n * @since 4.3.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.\n * @example\n *\n * _.isBuffer(new Buffer(2));\n * // => true\n *\n * _.isBuffer(new Uint8Array(2));\n * // => false\n */\nvar isBuffer = nativeIsBuffer || stubFalse;\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a function, else `false`.\n * @example\n *\n * _.isFunction(_);\n * // => true\n *\n * _.isFunction(/abc/);\n * // => false\n */\nfunction isFunction(value) {\n  if (!isObject(value)) {\n    return false;\n  }\n  // The use of `Object#toString` avoids issues with the `typeof` operator\n  // in Safari 9 which returns 'object' for typed arrays and other constructors.\n  var tag = baseGetTag(value);\n  return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;\n}\n\n/**\n * Checks if `value` is a valid array-like length.\n *\n * **Note:** This method is loosely based on\n * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n * @example\n *\n * _.isLength(3);\n * // => true\n *\n * _.isLength(Number.MIN_VALUE);\n * // => false\n *\n * _.isLength(Infinity);\n * // => false\n *\n * _.isLength('3');\n * // => false\n */\nfunction isLength(value) {\n  return typeof value == 'number' &&\n    value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n}\n\n/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return value != null && (type == 'object' || type == 'function');\n}\n\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return value != null && typeof value == 'object';\n}\n\n/**\n * Checks if `value` is a plain object, that is, an object created by the\n * `Object` constructor or one with a `[[Prototype]]` of `null`.\n *\n * @static\n * @memberOf _\n * @since 0.8.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n * }\n *\n * _.isPlainObject(new Foo);\n * // => false\n *\n * _.isPlainObject([1, 2, 3]);\n * // => false\n *\n * _.isPlainObject({ 'x': 0, 'y': 0 });\n * // => true\n *\n * _.isPlainObject(Object.create(null));\n * // => true\n */\nfunction isPlainObject(value) {\n  if (!isObjectLike(value) || baseGetTag(value) != objectTag) {\n    return false;\n  }\n  var proto = getPrototype(value);\n  if (proto === null) {\n    return true;\n  }\n  var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;\n  return typeof Ctor == 'function' && Ctor instanceof Ctor &&\n    funcToString.call(Ctor) == objectCtorString;\n}\n\n/**\n * Checks if `value` is classified as a typed array.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n * @example\n *\n * _.isTypedArray(new Uint8Array);\n * // => true\n *\n * _.isTypedArray([]);\n * // => false\n */\nvar isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;\n\n/**\n * Converts `value` to a plain object flattening inherited enumerable string\n * keyed properties of `value` to own properties of the plain object.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {Object} Returns the converted plain object.\n * @example\n *\n * function Foo() {\n *   this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.assign({ 'a': 1 }, new Foo);\n * // => { 'a': 1, 'b': 2 }\n *\n * _.assign({ 'a': 1 }, _.toPlainObject(new Foo));\n * // => { 'a': 1, 'b': 2, 'c': 3 }\n */\nfunction toPlainObject(value) {\n  return copyObject(value, keysIn(value));\n}\n\n/**\n * Creates an array of the own and inherited enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n *   this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keysIn(new Foo);\n * // => ['a', 'b', 'c'] (iteration order is not guaranteed)\n */\nfunction keysIn(object) {\n  return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);\n}\n\n/**\n * This method is like `_.merge` except that it accepts `customizer` which\n * is invoked to produce the merged values of the destination and source\n * properties. If `customizer` returns `undefined`, merging is handled by the\n * method instead. The `customizer` is invoked with six arguments:\n * (objValue, srcValue, key, object, source, stack).\n *\n * **Note:** This method mutates `object`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Object\n * @param {Object} object The destination object.\n * @param {...Object} sources The source objects.\n * @param {Function} customizer The function to customize assigned values.\n * @returns {Object} Returns `object`.\n * @example\n *\n * function customizer(objValue, srcValue) {\n *   if (_.isArray(objValue)) {\n *     return objValue.concat(srcValue);\n *   }\n * }\n *\n * var object = { 'a': [1], 'b': [2] };\n * var other = { 'a': [3], 'b': [4] };\n *\n * _.mergeWith(object, other, customizer);\n * // => { 'a': [1, 3], 'b': [2, 4] }\n */\nvar mergeWith = createAssigner(function(object, source, srcIndex, customizer) {\n  baseMerge(object, source, srcIndex, customizer);\n});\n\n/**\n * Creates a function that returns `value`.\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Util\n * @param {*} value The value to return from the new function.\n * @returns {Function} Returns the new constant function.\n * @example\n *\n * var objects = _.times(2, _.constant({ 'a': 1 }));\n *\n * console.log(objects);\n * // => [{ 'a': 1 }, { 'a': 1 }]\n *\n * console.log(objects[0] === objects[1]);\n * // => true\n */\nfunction constant(value) {\n  return function() {\n    return value;\n  };\n}\n\n/**\n * This method returns the first argument it receives.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Util\n * @param {*} value Any value.\n * @returns {*} Returns `value`.\n * @example\n *\n * var object = { 'a': 1 };\n *\n * console.log(_.identity(object) === object);\n * // => true\n */\nfunction identity(value) {\n  return value;\n}\n\n/**\n * This method returns `false`.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {boolean} Returns `false`.\n * @example\n *\n * _.times(2, _.stubFalse);\n * // => [false, false]\n */\nfunction stubFalse() {\n  return false;\n}\n\nmodule.exports = mergeWith;\n","/**\n * lodash (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright jQuery Foundation and other contributors <https://jquery.org/>\n * Released under MIT license <https://lodash.com/license>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n */\n\n/** Used as the size to enable large array optimizations. */\nvar LARGE_ARRAY_SIZE = 200;\n\n/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/** Used as references for various `Number` constants. */\nvar INFINITY = 1 / 0,\n    MAX_SAFE_INTEGER = 9007199254740991;\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]',\n    funcTag = '[object Function]',\n    genTag = '[object GeneratorFunction]',\n    symbolTag = '[object Symbol]';\n\n/**\n * Used to match `RegExp`\n * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).\n */\nvar reRegExpChar = /[\\\\^$.*+?()[\\]{}|]/g;\n\n/** Used to detect host constructors (Safari). */\nvar reIsHostCtor = /^\\[object .+?Constructor\\]$/;\n\n/** Used to detect unsigned integer values. */\nvar reIsUint = /^(?:0|[1-9]\\d*)$/;\n\n/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\n/**\n * A faster alternative to `Function#apply`, this function invokes `func`\n * with the `this` binding of `thisArg` and the arguments of `args`.\n *\n * @private\n * @param {Function} func The function to invoke.\n * @param {*} thisArg The `this` binding of `func`.\n * @param {Array} args The arguments to invoke `func` with.\n * @returns {*} Returns the result of `func`.\n */\nfunction apply(func, thisArg, args) {\n  switch (args.length) {\n    case 0: return func.call(thisArg);\n    case 1: return func.call(thisArg, args[0]);\n    case 2: return func.call(thisArg, args[0], args[1]);\n    case 3: return func.call(thisArg, args[0], args[1], args[2]);\n  }\n  return func.apply(thisArg, args);\n}\n\n/**\n * A specialized version of `_.includes` for arrays without support for\n * specifying an index to search from.\n *\n * @private\n * @param {Array} [array] The array to inspect.\n * @param {*} target The value to search for.\n * @returns {boolean} Returns `true` if `target` is found, else `false`.\n */\nfunction arrayIncludes(array, value) {\n  var length = array ? array.length : 0;\n  return !!length && baseIndexOf(array, value, 0) > -1;\n}\n\n/**\n * This function is like `arrayIncludes` except that it accepts a comparator.\n *\n * @private\n * @param {Array} [array] The array to inspect.\n * @param {*} target The value to search for.\n * @param {Function} comparator The comparator invoked per element.\n * @returns {boolean} Returns `true` if `target` is found, else `false`.\n */\nfunction arrayIncludesWith(array, value, comparator) {\n  var index = -1,\n      length = array ? array.length : 0;\n\n  while (++index < length) {\n    if (comparator(value, array[index])) {\n      return true;\n    }\n  }\n  return false;\n}\n\n/**\n * A specialized version of `_.map` for arrays without support for iteratee\n * shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the new mapped array.\n */\nfunction arrayMap(array, iteratee) {\n  var index = -1,\n      length = array ? array.length : 0,\n      result = Array(length);\n\n  while (++index < length) {\n    result[index] = iteratee(array[index], index, array);\n  }\n  return result;\n}\n\n/**\n * Appends the elements of `values` to `array`.\n *\n * @private\n * @param {Array} array The array to modify.\n * @param {Array} values The values to append.\n * @returns {Array} Returns `array`.\n */\nfunction arrayPush(array, values) {\n  var index = -1,\n      length = values.length,\n      offset = array.length;\n\n  while (++index < length) {\n    array[offset + index] = values[index];\n  }\n  return array;\n}\n\n/**\n * The base implementation of `_.findIndex` and `_.findLastIndex` without\n * support for iteratee shorthands.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {Function} predicate The function invoked per iteration.\n * @param {number} fromIndex The index to search from.\n * @param {boolean} [fromRight] Specify iterating from right to left.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\nfunction baseFindIndex(array, predicate, fromIndex, fromRight) {\n  var length = array.length,\n      index = fromIndex + (fromRight ? 1 : -1);\n\n  while ((fromRight ? index-- : ++index < length)) {\n    if (predicate(array[index], index, array)) {\n      return index;\n    }\n  }\n  return -1;\n}\n\n/**\n * The base implementation of `_.indexOf` without `fromIndex` bounds checks.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {*} value The value to search for.\n * @param {number} fromIndex The index to search from.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\nfunction baseIndexOf(array, value, fromIndex) {\n  if (value !== value) {\n    return baseFindIndex(array, baseIsNaN, fromIndex);\n  }\n  var index = fromIndex - 1,\n      length = array.length;\n\n  while (++index < length) {\n    if (array[index] === value) {\n      return index;\n    }\n  }\n  return -1;\n}\n\n/**\n * The base implementation of `_.isNaN` without support for number objects.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.\n */\nfunction baseIsNaN(value) {\n  return value !== value;\n}\n\n/**\n * The base implementation of `_.times` without support for iteratee shorthands\n * or max array length checks.\n *\n * @private\n * @param {number} n The number of times to invoke `iteratee`.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the array of results.\n */\nfunction baseTimes(n, iteratee) {\n  var index = -1,\n      result = Array(n);\n\n  while (++index < n) {\n    result[index] = iteratee(index);\n  }\n  return result;\n}\n\n/**\n * The base implementation of `_.unary` without support for storing metadata.\n *\n * @private\n * @param {Function} func The function to cap arguments for.\n * @returns {Function} Returns the new capped function.\n */\nfunction baseUnary(func) {\n  return function(value) {\n    return func(value);\n  };\n}\n\n/**\n * Checks if a cache value for `key` exists.\n *\n * @private\n * @param {Object} cache The cache to query.\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction cacheHas(cache, key) {\n  return cache.has(key);\n}\n\n/**\n * Gets the value at `key` of `object`.\n *\n * @private\n * @param {Object} [object] The object to query.\n * @param {string} key The key of the property to get.\n * @returns {*} Returns the property value.\n */\nfunction getValue(object, key) {\n  return object == null ? undefined : object[key];\n}\n\n/**\n * Checks if `value` is a host object in IE < 9.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a host object, else `false`.\n */\nfunction isHostObject(value) {\n  // Many host objects are `Object` objects that can coerce to strings\n  // despite having improperly defined `toString` methods.\n  var result = false;\n  if (value != null && typeof value.toString != 'function') {\n    try {\n      result = !!(value + '');\n    } catch (e) {}\n  }\n  return result;\n}\n\n/**\n * Creates a unary function that invokes `func` with its argument transformed.\n *\n * @private\n * @param {Function} func The function to wrap.\n * @param {Function} transform The argument transform.\n * @returns {Function} Returns the new function.\n */\nfunction overArg(func, transform) {\n  return function(arg) {\n    return func(transform(arg));\n  };\n}\n\n/** Used for built-in method references. */\nvar arrayProto = Array.prototype,\n    funcProto = Function.prototype,\n    objectProto = Object.prototype;\n\n/** Used to detect overreaching core-js shims. */\nvar coreJsData = root['__core-js_shared__'];\n\n/** Used to detect methods masquerading as native. */\nvar maskSrcKey = (function() {\n  var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');\n  return uid ? ('Symbol(src)_1.' + uid) : '';\n}());\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar objectToString = objectProto.toString;\n\n/** Used to detect if a method is native. */\nvar reIsNative = RegExp('^' +\n  funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\\\$&')\n  .replace(/hasOwnProperty|(function).*?(?=\\\\\\()| for .+?(?=\\\\\\])/g, '$1.*?') + '$'\n);\n\n/** Built-in value references. */\nvar Symbol = root.Symbol,\n    getPrototype = overArg(Object.getPrototypeOf, Object),\n    propertyIsEnumerable = objectProto.propertyIsEnumerable,\n    splice = arrayProto.splice,\n    spreadableSymbol = Symbol ? Symbol.isConcatSpreadable : undefined;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeGetSymbols = Object.getOwnPropertySymbols,\n    nativeMax = Math.max;\n\n/* Built-in method references that are verified to be native. */\nvar Map = getNative(root, 'Map'),\n    nativeCreate = getNative(Object, 'create');\n\n/**\n * Creates a hash object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Hash(entries) {\n  var index = -1,\n      length = entries ? entries.length : 0;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n/**\n * Removes all key-value entries from the hash.\n *\n * @private\n * @name clear\n * @memberOf Hash\n */\nfunction hashClear() {\n  this.__data__ = nativeCreate ? nativeCreate(null) : {};\n}\n\n/**\n * Removes `key` and its value from the hash.\n *\n * @private\n * @name delete\n * @memberOf Hash\n * @param {Object} hash The hash to modify.\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction hashDelete(key) {\n  return this.has(key) && delete this.__data__[key];\n}\n\n/**\n * Gets the hash value for `key`.\n *\n * @private\n * @name get\n * @memberOf Hash\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction hashGet(key) {\n  var data = this.__data__;\n  if (nativeCreate) {\n    var result = data[key];\n    return result === HASH_UNDEFINED ? undefined : result;\n  }\n  return hasOwnProperty.call(data, key) ? data[key] : undefined;\n}\n\n/**\n * Checks if a hash value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Hash\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction hashHas(key) {\n  var data = this.__data__;\n  return nativeCreate ? data[key] !== undefined : hasOwnProperty.call(data, key);\n}\n\n/**\n * Sets the hash `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Hash\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the hash instance.\n */\nfunction hashSet(key, value) {\n  var data = this.__data__;\n  data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;\n  return this;\n}\n\n// Add methods to `Hash`.\nHash.prototype.clear = hashClear;\nHash.prototype['delete'] = hashDelete;\nHash.prototype.get = hashGet;\nHash.prototype.has = hashHas;\nHash.prototype.set = hashSet;\n\n/**\n * Creates an list cache object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction ListCache(entries) {\n  var index = -1,\n      length = entries ? entries.length : 0;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n/**\n * Removes all key-value entries from the list cache.\n *\n * @private\n * @name clear\n * @memberOf ListCache\n */\nfunction listCacheClear() {\n  this.__data__ = [];\n}\n\n/**\n * Removes `key` and its value from the list cache.\n *\n * @private\n * @name delete\n * @memberOf ListCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction listCacheDelete(key) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  if (index < 0) {\n    return false;\n  }\n  var lastIndex = data.length - 1;\n  if (index == lastIndex) {\n    data.pop();\n  } else {\n    splice.call(data, index, 1);\n  }\n  return true;\n}\n\n/**\n * Gets the list cache value for `key`.\n *\n * @private\n * @name get\n * @memberOf ListCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction listCacheGet(key) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  return index < 0 ? undefined : data[index][1];\n}\n\n/**\n * Checks if a list cache value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf ListCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction listCacheHas(key) {\n  return assocIndexOf(this.__data__, key) > -1;\n}\n\n/**\n * Sets the list cache `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf ListCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the list cache instance.\n */\nfunction listCacheSet(key, value) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  if (index < 0) {\n    data.push([key, value]);\n  } else {\n    data[index][1] = value;\n  }\n  return this;\n}\n\n// Add methods to `ListCache`.\nListCache.prototype.clear = listCacheClear;\nListCache.prototype['delete'] = listCacheDelete;\nListCache.prototype.get = listCacheGet;\nListCache.prototype.has = listCacheHas;\nListCache.prototype.set = listCacheSet;\n\n/**\n * Creates a map cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction MapCache(entries) {\n  var index = -1,\n      length = entries ? entries.length : 0;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n/**\n * Removes all key-value entries from the map.\n *\n * @private\n * @name clear\n * @memberOf MapCache\n */\nfunction mapCacheClear() {\n  this.__data__ = {\n    'hash': new Hash,\n    'map': new (Map || ListCache),\n    'string': new Hash\n  };\n}\n\n/**\n * Removes `key` and its value from the map.\n *\n * @private\n * @name delete\n * @memberOf MapCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction mapCacheDelete(key) {\n  return getMapData(this, key)['delete'](key);\n}\n\n/**\n * Gets the map value for `key`.\n *\n * @private\n * @name get\n * @memberOf MapCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction mapCacheGet(key) {\n  return getMapData(this, key).get(key);\n}\n\n/**\n * Checks if a map value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf MapCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction mapCacheHas(key) {\n  return getMapData(this, key).has(key);\n}\n\n/**\n * Sets the map `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf MapCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the map cache instance.\n */\nfunction mapCacheSet(key, value) {\n  getMapData(this, key).set(key, value);\n  return this;\n}\n\n// Add methods to `MapCache`.\nMapCache.prototype.clear = mapCacheClear;\nMapCache.prototype['delete'] = mapCacheDelete;\nMapCache.prototype.get = mapCacheGet;\nMapCache.prototype.has = mapCacheHas;\nMapCache.prototype.set = mapCacheSet;\n\n/**\n *\n * Creates an array cache object to store unique values.\n *\n * @private\n * @constructor\n * @param {Array} [values] The values to cache.\n */\nfunction SetCache(values) {\n  var index = -1,\n      length = values ? values.length : 0;\n\n  this.__data__ = new MapCache;\n  while (++index < length) {\n    this.add(values[index]);\n  }\n}\n\n/**\n * Adds `value` to the array cache.\n *\n * @private\n * @name add\n * @memberOf SetCache\n * @alias push\n * @param {*} value The value to cache.\n * @returns {Object} Returns the cache instance.\n */\nfunction setCacheAdd(value) {\n  this.__data__.set(value, HASH_UNDEFINED);\n  return this;\n}\n\n/**\n * Checks if `value` is in the array cache.\n *\n * @private\n * @name has\n * @memberOf SetCache\n * @param {*} value The value to search for.\n * @returns {number} Returns `true` if `value` is found, else `false`.\n */\nfunction setCacheHas(value) {\n  return this.__data__.has(value);\n}\n\n// Add methods to `SetCache`.\nSetCache.prototype.add = SetCache.prototype.push = setCacheAdd;\nSetCache.prototype.has = setCacheHas;\n\n/**\n * Creates an array of the enumerable property names of the array-like `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @param {boolean} inherited Specify returning inherited property names.\n * @returns {Array} Returns the array of property names.\n */\nfunction arrayLikeKeys(value, inherited) {\n  // Safari 8.1 makes `arguments.callee` enumerable in strict mode.\n  // Safari 9 makes `arguments.length` enumerable in strict mode.\n  var result = (isArray(value) || isArguments(value))\n    ? baseTimes(value.length, String)\n    : [];\n\n  var length = result.length,\n      skipIndexes = !!length;\n\n  for (var key in value) {\n    if ((inherited || hasOwnProperty.call(value, key)) &&\n        !(skipIndexes && (key == 'length' || isIndex(key, length)))) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\n/**\n * Gets the index at which the `key` is found in `array` of key-value pairs.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {*} key The key to search for.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\nfunction assocIndexOf(array, key) {\n  var length = array.length;\n  while (length--) {\n    if (eq(array[length][0], key)) {\n      return length;\n    }\n  }\n  return -1;\n}\n\n/**\n * The base implementation of methods like `_.difference` without support\n * for excluding multiple arrays or iteratee shorthands.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {Array} values The values to exclude.\n * @param {Function} [iteratee] The iteratee invoked per element.\n * @param {Function} [comparator] The comparator invoked per element.\n * @returns {Array} Returns the new array of filtered values.\n */\nfunction baseDifference(array, values, iteratee, comparator) {\n  var index = -1,\n      includes = arrayIncludes,\n      isCommon = true,\n      length = array.length,\n      result = [],\n      valuesLength = values.length;\n\n  if (!length) {\n    return result;\n  }\n  if (iteratee) {\n    values = arrayMap(values, baseUnary(iteratee));\n  }\n  if (comparator) {\n    includes = arrayIncludesWith;\n    isCommon = false;\n  }\n  else if (values.length >= LARGE_ARRAY_SIZE) {\n    includes = cacheHas;\n    isCommon = false;\n    values = new SetCache(values);\n  }\n  outer:\n  while (++index < length) {\n    var value = array[index],\n        computed = iteratee ? iteratee(value) : value;\n\n    value = (comparator || value !== 0) ? value : 0;\n    if (isCommon && computed === computed) {\n      var valuesIndex = valuesLength;\n      while (valuesIndex--) {\n        if (values[valuesIndex] === computed) {\n          continue outer;\n        }\n      }\n      result.push(value);\n    }\n    else if (!includes(values, computed, comparator)) {\n      result.push(value);\n    }\n  }\n  return result;\n}\n\n/**\n * The base implementation of `_.flatten` with support for restricting flattening.\n *\n * @private\n * @param {Array} array The array to flatten.\n * @param {number} depth The maximum recursion depth.\n * @param {boolean} [predicate=isFlattenable] The function invoked per iteration.\n * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks.\n * @param {Array} [result=[]] The initial result value.\n * @returns {Array} Returns the new flattened array.\n */\nfunction baseFlatten(array, depth, predicate, isStrict, result) {\n  var index = -1,\n      length = array.length;\n\n  predicate || (predicate = isFlattenable);\n  result || (result = []);\n\n  while (++index < length) {\n    var value = array[index];\n    if (depth > 0 && predicate(value)) {\n      if (depth > 1) {\n        // Recursively flatten arrays (susceptible to call stack limits).\n        baseFlatten(value, depth - 1, predicate, isStrict, result);\n      } else {\n        arrayPush(result, value);\n      }\n    } else if (!isStrict) {\n      result[result.length] = value;\n    }\n  }\n  return result;\n}\n\n/**\n * The base implementation of `getAllKeys` and `getAllKeysIn` which uses\n * `keysFunc` and `symbolsFunc` to get the enumerable property names and\n * symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Function} keysFunc The function to get the keys of `object`.\n * @param {Function} symbolsFunc The function to get the symbols of `object`.\n * @returns {Array} Returns the array of property names and symbols.\n */\nfunction baseGetAllKeys(object, keysFunc, symbolsFunc) {\n  var result = keysFunc(object);\n  return isArray(object) ? result : arrayPush(result, symbolsFunc(object));\n}\n\n/**\n * The base implementation of `_.isNative` without bad shim checks.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a native function,\n *  else `false`.\n */\nfunction baseIsNative(value) {\n  if (!isObject(value) || isMasked(value)) {\n    return false;\n  }\n  var pattern = (isFunction(value) || isHostObject(value)) ? reIsNative : reIsHostCtor;\n  return pattern.test(toSource(value));\n}\n\n/**\n * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction baseKeysIn(object) {\n  if (!isObject(object)) {\n    return nativeKeysIn(object);\n  }\n  var isProto = isPrototype(object),\n      result = [];\n\n  for (var key in object) {\n    if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\n/**\n * The base implementation of `_.pick` without support for individual\n * property identifiers.\n *\n * @private\n * @param {Object} object The source object.\n * @param {string[]} props The property identifiers to pick.\n * @returns {Object} Returns the new object.\n */\nfunction basePick(object, props) {\n  object = Object(object);\n  return basePickBy(object, props, function(value, key) {\n    return key in object;\n  });\n}\n\n/**\n * The base implementation of  `_.pickBy` without support for iteratee shorthands.\n *\n * @private\n * @param {Object} object The source object.\n * @param {string[]} props The property identifiers to pick from.\n * @param {Function} predicate The function invoked per property.\n * @returns {Object} Returns the new object.\n */\nfunction basePickBy(object, props, predicate) {\n  var index = -1,\n      length = props.length,\n      result = {};\n\n  while (++index < length) {\n    var key = props[index],\n        value = object[key];\n\n    if (predicate(value, key)) {\n      result[key] = value;\n    }\n  }\n  return result;\n}\n\n/**\n * The base implementation of `_.rest` which doesn't validate or coerce arguments.\n *\n * @private\n * @param {Function} func The function to apply a rest parameter to.\n * @param {number} [start=func.length-1] The start position of the rest parameter.\n * @returns {Function} Returns the new function.\n */\nfunction baseRest(func, start) {\n  start = nativeMax(start === undefined ? (func.length - 1) : start, 0);\n  return function() {\n    var args = arguments,\n        index = -1,\n        length = nativeMax(args.length - start, 0),\n        array = Array(length);\n\n    while (++index < length) {\n      array[index] = args[start + index];\n    }\n    index = -1;\n    var otherArgs = Array(start + 1);\n    while (++index < start) {\n      otherArgs[index] = args[index];\n    }\n    otherArgs[start] = array;\n    return apply(func, this, otherArgs);\n  };\n}\n\n/**\n * Creates an array of own and inherited enumerable property names and\n * symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names and symbols.\n */\nfunction getAllKeysIn(object) {\n  return baseGetAllKeys(object, keysIn, getSymbolsIn);\n}\n\n/**\n * Gets the data for `map`.\n *\n * @private\n * @param {Object} map The map to query.\n * @param {string} key The reference key.\n * @returns {*} Returns the map data.\n */\nfunction getMapData(map, key) {\n  var data = map.__data__;\n  return isKeyable(key)\n    ? data[typeof key == 'string' ? 'string' : 'hash']\n    : data.map;\n}\n\n/**\n * Gets the native function at `key` of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the method to get.\n * @returns {*} Returns the function if it's native, else `undefined`.\n */\nfunction getNative(object, key) {\n  var value = getValue(object, key);\n  return baseIsNative(value) ? value : undefined;\n}\n\n/**\n * Creates an array of the own enumerable symbol properties of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of symbols.\n */\nvar getSymbols = nativeGetSymbols ? overArg(nativeGetSymbols, Object) : stubArray;\n\n/**\n * Creates an array of the own and inherited enumerable symbol properties\n * of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of symbols.\n */\nvar getSymbolsIn = !nativeGetSymbols ? stubArray : function(object) {\n  var result = [];\n  while (object) {\n    arrayPush(result, getSymbols(object));\n    object = getPrototype(object);\n  }\n  return result;\n};\n\n/**\n * Checks if `value` is a flattenable `arguments` object or array.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is flattenable, else `false`.\n */\nfunction isFlattenable(value) {\n  return isArray(value) || isArguments(value) ||\n    !!(spreadableSymbol && value && value[spreadableSymbol]);\n}\n\n/**\n * Checks if `value` is a valid array-like index.\n *\n * @private\n * @param {*} value The value to check.\n * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.\n * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.\n */\nfunction isIndex(value, length) {\n  length = length == null ? MAX_SAFE_INTEGER : length;\n  return !!length &&\n    (typeof value == 'number' || reIsUint.test(value)) &&\n    (value > -1 && value % 1 == 0 && value < length);\n}\n\n/**\n * Checks if `value` is suitable for use as unique object key.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is suitable, else `false`.\n */\nfunction isKeyable(value) {\n  var type = typeof value;\n  return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')\n    ? (value !== '__proto__')\n    : (value === null);\n}\n\n/**\n * Checks if `func` has its source masked.\n *\n * @private\n * @param {Function} func The function to check.\n * @returns {boolean} Returns `true` if `func` is masked, else `false`.\n */\nfunction isMasked(func) {\n  return !!maskSrcKey && (maskSrcKey in func);\n}\n\n/**\n * Checks if `value` is likely a prototype object.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.\n */\nfunction isPrototype(value) {\n  var Ctor = value && value.constructor,\n      proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;\n\n  return value === proto;\n}\n\n/**\n * This function is like\n * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * except that it includes inherited enumerable properties.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction nativeKeysIn(object) {\n  var result = [];\n  if (object != null) {\n    for (var key in Object(object)) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\n/**\n * Converts `value` to a string key if it's not a string or symbol.\n *\n * @private\n * @param {*} value The value to inspect.\n * @returns {string|symbol} Returns the key.\n */\nfunction toKey(value) {\n  if (typeof value == 'string' || isSymbol(value)) {\n    return value;\n  }\n  var result = (value + '');\n  return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;\n}\n\n/**\n * Converts `func` to its source code.\n *\n * @private\n * @param {Function} func The function to process.\n * @returns {string} Returns the source code.\n */\nfunction toSource(func) {\n  if (func != null) {\n    try {\n      return funcToString.call(func);\n    } catch (e) {}\n    try {\n      return (func + '');\n    } catch (e) {}\n  }\n  return '';\n}\n\n/**\n * Performs a\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * comparison between two values to determine if they are equivalent.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * var object = { 'a': 1 };\n * var other = { 'a': 1 };\n *\n * _.eq(object, object);\n * // => true\n *\n * _.eq(object, other);\n * // => false\n *\n * _.eq('a', 'a');\n * // => true\n *\n * _.eq('a', Object('a'));\n * // => false\n *\n * _.eq(NaN, NaN);\n * // => true\n */\nfunction eq(value, other) {\n  return value === other || (value !== value && other !== other);\n}\n\n/**\n * Checks if `value` is likely an `arguments` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n *  else `false`.\n * @example\n *\n * _.isArguments(function() { return arguments; }());\n * // => true\n *\n * _.isArguments([1, 2, 3]);\n * // => false\n */\nfunction isArguments(value) {\n  // Safari 8.1 makes `arguments.callee` enumerable in strict mode.\n  return isArrayLikeObject(value) && hasOwnProperty.call(value, 'callee') &&\n    (!propertyIsEnumerable.call(value, 'callee') || objectToString.call(value) == argsTag);\n}\n\n/**\n * Checks if `value` is classified as an `Array` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array, else `false`.\n * @example\n *\n * _.isArray([1, 2, 3]);\n * // => true\n *\n * _.isArray(document.body.children);\n * // => false\n *\n * _.isArray('abc');\n * // => false\n *\n * _.isArray(_.noop);\n * // => false\n */\nvar isArray = Array.isArray;\n\n/**\n * Checks if `value` is array-like. A value is considered array-like if it's\n * not a function and has a `value.length` that's an integer greater than or\n * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n * @example\n *\n * _.isArrayLike([1, 2, 3]);\n * // => true\n *\n * _.isArrayLike(document.body.children);\n * // => true\n *\n * _.isArrayLike('abc');\n * // => true\n *\n * _.isArrayLike(_.noop);\n * // => false\n */\nfunction isArrayLike(value) {\n  return value != null && isLength(value.length) && !isFunction(value);\n}\n\n/**\n * This method is like `_.isArrayLike` except that it also checks if `value`\n * is an object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array-like object,\n *  else `false`.\n * @example\n *\n * _.isArrayLikeObject([1, 2, 3]);\n * // => true\n *\n * _.isArrayLikeObject(document.body.children);\n * // => true\n *\n * _.isArrayLikeObject('abc');\n * // => false\n *\n * _.isArrayLikeObject(_.noop);\n * // => false\n */\nfunction isArrayLikeObject(value) {\n  return isObjectLike(value) && isArrayLike(value);\n}\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a function, else `false`.\n * @example\n *\n * _.isFunction(_);\n * // => true\n *\n * _.isFunction(/abc/);\n * // => false\n */\nfunction isFunction(value) {\n  // The use of `Object#toString` avoids issues with the `typeof` operator\n  // in Safari 8-9 which returns 'object' for typed array and other constructors.\n  var tag = isObject(value) ? objectToString.call(value) : '';\n  return tag == funcTag || tag == genTag;\n}\n\n/**\n * Checks if `value` is a valid array-like length.\n *\n * **Note:** This method is loosely based on\n * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n * @example\n *\n * _.isLength(3);\n * // => true\n *\n * _.isLength(Number.MIN_VALUE);\n * // => false\n *\n * _.isLength(Infinity);\n * // => false\n *\n * _.isLength('3');\n * // => false\n */\nfunction isLength(value) {\n  return typeof value == 'number' &&\n    value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n}\n\n/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return !!value && (type == 'object' || type == 'function');\n}\n\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return !!value && typeof value == 'object';\n}\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n  return typeof value == 'symbol' ||\n    (isObjectLike(value) && objectToString.call(value) == symbolTag);\n}\n\n/**\n * Creates an array of the own and inherited enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n *   this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keysIn(new Foo);\n * // => ['a', 'b', 'c'] (iteration order is not guaranteed)\n */\nfunction keysIn(object) {\n  return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);\n}\n\n/**\n * The opposite of `_.pick`; this method creates an object composed of the\n * own and inherited enumerable string keyed properties of `object` that are\n * not omitted.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The source object.\n * @param {...(string|string[])} [props] The property identifiers to omit.\n * @returns {Object} Returns the new object.\n * @example\n *\n * var object = { 'a': 1, 'b': '2', 'c': 3 };\n *\n * _.omit(object, ['a', 'c']);\n * // => { 'b': '2' }\n */\nvar omit = baseRest(function(object, props) {\n  if (object == null) {\n    return {};\n  }\n  props = arrayMap(baseFlatten(props, 1), toKey);\n  return basePick(object, baseDifference(getAllKeysIn(object), props));\n});\n\n/**\n * This method returns a new empty array.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {Array} Returns the new empty array.\n * @example\n *\n * var arrays = _.times(2, _.stubArray);\n *\n * console.log(arrays);\n * // => [[], []]\n *\n * console.log(arrays[0] === arrays[1]);\n * // => false\n */\nfunction stubArray() {\n  return [];\n}\n\nmodule.exports = omit;\n","'use strict';\nconst strictUriEncode = require('strict-uri-encode');\nconst decodeComponent = require('decode-uri-component');\nconst splitOnFirst = require('split-on-first');\nconst filterObject = require('filter-obj');\n\nconst isNullOrUndefined = value => value === null || value === undefined;\n\nfunction encoderForArrayFormat(options) {\n\tswitch (options.arrayFormat) {\n\t\tcase 'index':\n\t\t\treturn key => (result, value) => {\n\t\t\t\tconst index = result.length;\n\n\t\t\t\tif (\n\t\t\t\t\tvalue === undefined ||\n\t\t\t\t\t(options.skipNull && value === null) ||\n\t\t\t\t\t(options.skipEmptyString && value === '')\n\t\t\t\t) {\n\t\t\t\t\treturn result;\n\t\t\t\t}\n\n\t\t\t\tif (value === null) {\n\t\t\t\t\treturn [...result, [encode(key, options), '[', index, ']'].join('')];\n\t\t\t\t}\n\n\t\t\t\treturn [\n\t\t\t\t\t...result,\n\t\t\t\t\t[encode(key, options), '[', encode(index, options), ']=', encode(value, options)].join('')\n\t\t\t\t];\n\t\t\t};\n\n\t\tcase 'bracket':\n\t\t\treturn key => (result, value) => {\n\t\t\t\tif (\n\t\t\t\t\tvalue === undefined ||\n\t\t\t\t\t(options.skipNull && value === null) ||\n\t\t\t\t\t(options.skipEmptyString && value === '')\n\t\t\t\t) {\n\t\t\t\t\treturn result;\n\t\t\t\t}\n\n\t\t\t\tif (value === null) {\n\t\t\t\t\treturn [...result, [encode(key, options), '[]'].join('')];\n\t\t\t\t}\n\n\t\t\t\treturn [...result, [encode(key, options), '[]=', encode(value, options)].join('')];\n\t\t\t};\n\n\t\tcase 'comma':\n\t\tcase 'separator':\n\t\t\treturn key => (result, value) => {\n\t\t\t\tif (value === null || value === undefined || value.length === 0) {\n\t\t\t\t\treturn result;\n\t\t\t\t}\n\n\t\t\t\tif (result.length === 0) {\n\t\t\t\t\treturn [[encode(key, options), '=', encode(value, options)].join('')];\n\t\t\t\t}\n\n\t\t\t\treturn [[result, encode(value, options)].join(options.arrayFormatSeparator)];\n\t\t\t};\n\n\t\tdefault:\n\t\t\treturn key => (result, value) => {\n\t\t\t\tif (\n\t\t\t\t\tvalue === undefined ||\n\t\t\t\t\t(options.skipNull && value === null) ||\n\t\t\t\t\t(options.skipEmptyString && value === '')\n\t\t\t\t) {\n\t\t\t\t\treturn result;\n\t\t\t\t}\n\n\t\t\t\tif (value === null) {\n\t\t\t\t\treturn [...result, encode(key, options)];\n\t\t\t\t}\n\n\t\t\t\treturn [...result, [encode(key, options), '=', encode(value, options)].join('')];\n\t\t\t};\n\t}\n}\n\nfunction parserForArrayFormat(options) {\n\tlet result;\n\n\tswitch (options.arrayFormat) {\n\t\tcase 'index':\n\t\t\treturn (key, value, accumulator) => {\n\t\t\t\tresult = /\\[(\\d*)\\]$/.exec(key);\n\n\t\t\t\tkey = key.replace(/\\[\\d*\\]$/, '');\n\n\t\t\t\tif (!result) {\n\t\t\t\t\taccumulator[key] = value;\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tif (accumulator[key] === undefined) {\n\t\t\t\t\taccumulator[key] = {};\n\t\t\t\t}\n\n\t\t\t\taccumulator[key][result[1]] = value;\n\t\t\t};\n\n\t\tcase 'bracket':\n\t\t\treturn (key, value, accumulator) => {\n\t\t\t\tresult = /(\\[\\])$/.exec(key);\n\t\t\t\tkey = key.replace(/\\[\\]$/, '');\n\n\t\t\t\tif (!result) {\n\t\t\t\t\taccumulator[key] = value;\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tif (accumulator[key] === undefined) {\n\t\t\t\t\taccumulator[key] = [value];\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\taccumulator[key] = [].concat(accumulator[key], value);\n\t\t\t};\n\n\t\tcase 'comma':\n\t\tcase 'separator':\n\t\t\treturn (key, value, accumulator) => {\n\t\t\t\tconst isArray = typeof value === 'string' && value.includes(options.arrayFormatSeparator);\n\t\t\t\tconst isEncodedArray = (typeof value === 'string' && !isArray && decode(value, options).includes(options.arrayFormatSeparator));\n\t\t\t\tvalue = isEncodedArray ? decode(value, options) : value;\n\t\t\t\tconst newValue = isArray || isEncodedArray ? value.split(options.arrayFormatSeparator).map(item => decode(item, options)) : value === null ? value : decode(value, options);\n\t\t\t\taccumulator[key] = newValue;\n\t\t\t};\n\n\t\tdefault:\n\t\t\treturn (key, value, accumulator) => {\n\t\t\t\tif (accumulator[key] === undefined) {\n\t\t\t\t\taccumulator[key] = value;\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\taccumulator[key] = [].concat(accumulator[key], value);\n\t\t\t};\n\t}\n}\n\nfunction validateArrayFormatSeparator(value) {\n\tif (typeof value !== 'string' || value.length !== 1) {\n\t\tthrow new TypeError('arrayFormatSeparator must be single character string');\n\t}\n}\n\nfunction encode(value, options) {\n\tif (options.encode) {\n\t\treturn options.strict ? strictUriEncode(value) : encodeURIComponent(value);\n\t}\n\n\treturn value;\n}\n\nfunction decode(value, options) {\n\tif (options.decode) {\n\t\treturn decodeComponent(value);\n\t}\n\n\treturn value;\n}\n\nfunction keysSorter(input) {\n\tif (Array.isArray(input)) {\n\t\treturn input.sort();\n\t}\n\n\tif (typeof input === 'object') {\n\t\treturn keysSorter(Object.keys(input))\n\t\t\t.sort((a, b) => Number(a) - Number(b))\n\t\t\t.map(key => input[key]);\n\t}\n\n\treturn input;\n}\n\nfunction removeHash(input) {\n\tconst hashStart = input.indexOf('#');\n\tif (hashStart !== -1) {\n\t\tinput = input.slice(0, hashStart);\n\t}\n\n\treturn input;\n}\n\nfunction getHash(url) {\n\tlet hash = '';\n\tconst hashStart = url.indexOf('#');\n\tif (hashStart !== -1) {\n\t\thash = url.slice(hashStart);\n\t}\n\n\treturn hash;\n}\n\nfunction extract(input) {\n\tinput = removeHash(input);\n\tconst queryStart = input.indexOf('?');\n\tif (queryStart === -1) {\n\t\treturn '';\n\t}\n\n\treturn input.slice(queryStart + 1);\n}\n\nfunction parseValue(value, options) {\n\tif (options.parseNumbers && !Number.isNaN(Number(value)) && (typeof value === 'string' && value.trim() !== '')) {\n\t\tvalue = Number(value);\n\t} else if (options.parseBooleans && value !== null && (value.toLowerCase() === 'true' || value.toLowerCase() === 'false')) {\n\t\tvalue = value.toLowerCase() === 'true';\n\t}\n\n\treturn value;\n}\n\nfunction parse(query, options) {\n\toptions = Object.assign({\n\t\tdecode: true,\n\t\tsort: true,\n\t\tarrayFormat: 'none',\n\t\tarrayFormatSeparator: ',',\n\t\tparseNumbers: false,\n\t\tparseBooleans: false\n\t}, options);\n\n\tvalidateArrayFormatSeparator(options.arrayFormatSeparator);\n\n\tconst formatter = parserForArrayFormat(options);\n\n\t// Create an object with no prototype\n\tconst ret = Object.create(null);\n\n\tif (typeof query !== 'string') {\n\t\treturn ret;\n\t}\n\n\tquery = query.trim().replace(/^[?#&]/, '');\n\n\tif (!query) {\n\t\treturn ret;\n\t}\n\n\tfor (const param of query.split('&')) {\n\t\tif (param === '') {\n\t\t\tcontinue;\n\t\t}\n\n\t\tlet [key, value] = splitOnFirst(options.decode ? param.replace(/\\+/g, ' ') : param, '=');\n\n\t\t// Missing `=` should be `null`:\n\t\t// http://w3.org/TR/2012/WD-url-20120524/#collect-url-parameters\n\t\tvalue = value === undefined ? null : ['comma', 'separator'].includes(options.arrayFormat) ? value : decode(value, options);\n\t\tformatter(decode(key, options), value, ret);\n\t}\n\n\tfor (const key of Object.keys(ret)) {\n\t\tconst value = ret[key];\n\t\tif (typeof value === 'object' && value !== null) {\n\t\t\tfor (const k of Object.keys(value)) {\n\t\t\t\tvalue[k] = parseValue(value[k], options);\n\t\t\t}\n\t\t} else {\n\t\t\tret[key] = parseValue(value, options);\n\t\t}\n\t}\n\n\tif (options.sort === false) {\n\t\treturn ret;\n\t}\n\n\treturn (options.sort === true ? Object.keys(ret).sort() : Object.keys(ret).sort(options.sort)).reduce((result, key) => {\n\t\tconst value = ret[key];\n\t\tif (Boolean(value) && typeof value === 'object' && !Array.isArray(value)) {\n\t\t\t// Sort object keys, not values\n\t\t\tresult[key] = keysSorter(value);\n\t\t} else {\n\t\t\tresult[key] = value;\n\t\t}\n\n\t\treturn result;\n\t}, Object.create(null));\n}\n\nexports.extract = extract;\nexports.parse = parse;\n\nexports.stringify = (object, options) => {\n\tif (!object) {\n\t\treturn '';\n\t}\n\n\toptions = Object.assign({\n\t\tencode: true,\n\t\tstrict: true,\n\t\tarrayFormat: 'none',\n\t\tarrayFormatSeparator: ','\n\t}, options);\n\n\tvalidateArrayFormatSeparator(options.arrayFormatSeparator);\n\n\tconst shouldFilter = key => (\n\t\t(options.skipNull && isNullOrUndefined(object[key])) ||\n\t\t(options.skipEmptyString && object[key] === '')\n\t);\n\n\tconst formatter = encoderForArrayFormat(options);\n\n\tconst objectCopy = {};\n\n\tfor (const key of Object.keys(object)) {\n\t\tif (!shouldFilter(key)) {\n\t\t\tobjectCopy[key] = object[key];\n\t\t}\n\t}\n\n\tconst keys = Object.keys(objectCopy);\n\n\tif (options.sort !== false) {\n\t\tkeys.sort(options.sort);\n\t}\n\n\treturn keys.map(key => {\n\t\tconst value = object[key];\n\n\t\tif (value === undefined) {\n\t\t\treturn '';\n\t\t}\n\n\t\tif (value === null) {\n\t\t\treturn encode(key, options);\n\t\t}\n\n\t\tif (Array.isArray(value)) {\n\t\t\treturn value\n\t\t\t\t.reduce(formatter(key), [])\n\t\t\t\t.join('&');\n\t\t}\n\n\t\treturn encode(key, options) + '=' + encode(value, options);\n\t}).filter(x => x.length > 0).join('&');\n};\n\nexports.parseUrl = (url, options) => {\n\toptions = Object.assign({\n\t\tdecode: true\n\t}, options);\n\n\tconst [url_, hash] = splitOnFirst(url, '#');\n\n\treturn Object.assign(\n\t\t{\n\t\t\turl: url_.split('?')[0] || '',\n\t\t\tquery: parse(extract(url), options)\n\t\t},\n\t\toptions && options.parseFragmentIdentifier && hash ? {fragmentIdentifier: decode(hash, options)} : {}\n\t);\n};\n\nexports.stringifyUrl = (object, options) => {\n\toptions = Object.assign({\n\t\tencode: true,\n\t\tstrict: true\n\t}, options);\n\n\tconst url = removeHash(object.url).split('?')[0] || '';\n\tconst queryFromUrl = exports.extract(object.url);\n\tconst parsedQueryFromUrl = exports.parse(queryFromUrl, {sort: false});\n\n\tconst query = Object.assign(parsedQueryFromUrl, object.query);\n\tlet queryString = exports.stringify(query, options);\n\tif (queryString) {\n\t\tqueryString = `?${queryString}`;\n\t}\n\n\tlet hash = getHash(object.url);\n\tif (object.fragmentIdentifier) {\n\t\thash = `#${encode(object.fragmentIdentifier, options)}`;\n\t}\n\n\treturn `${url}${queryString}${hash}`;\n};\n\nexports.pick = (input, filter, options) => {\n\toptions = Object.assign({\n\t\tparseFragmentIdentifier: true\n\t}, options);\n\n\tconst {url, query, fragmentIdentifier} = exports.parseUrl(input, options);\n\treturn exports.stringifyUrl({\n\t\turl,\n\t\tquery: filterObject(query, filter),\n\t\tfragmentIdentifier\n\t}, options);\n};\n\nexports.exclude = (input, filter, options) => {\n\tconst exclusionFilter = Array.isArray(filter) ? key => !filter.includes(key) : (key, value) => !filter(key, value);\n\n\treturn exports.pick(input, exclusionFilter, options);\n};\n","var __extends = (this && this.__extends) || (function () {\n    var extendStatics = function (d, b) {\n        extendStatics = Object.setPrototypeOf ||\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nvar __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nimport * as React from 'react';\nvar rowSizeBase = {\n    width: '100%',\n    height: '10px',\n    top: '0px',\n    left: '0px',\n    cursor: 'row-resize',\n};\nvar colSizeBase = {\n    width: '10px',\n    height: '100%',\n    top: '0px',\n    left: '0px',\n    cursor: 'col-resize',\n};\nvar edgeBase = {\n    width: '20px',\n    height: '20px',\n    position: 'absolute',\n};\nvar styles = {\n    top: __assign(__assign({}, rowSizeBase), { top: '-5px' }),\n    right: __assign(__assign({}, colSizeBase), { left: undefined, right: '-5px' }),\n    bottom: __assign(__assign({}, rowSizeBase), { top: undefined, bottom: '-5px' }),\n    left: __assign(__assign({}, colSizeBase), { left: '-5px' }),\n    topRight: __assign(__assign({}, edgeBase), { right: '-10px', top: '-10px', cursor: 'ne-resize' }),\n    bottomRight: __assign(__assign({}, edgeBase), { right: '-10px', bottom: '-10px', cursor: 'se-resize' }),\n    bottomLeft: __assign(__assign({}, edgeBase), { left: '-10px', bottom: '-10px', cursor: 'sw-resize' }),\n    topLeft: __assign(__assign({}, edgeBase), { left: '-10px', top: '-10px', cursor: 'nw-resize' }),\n};\nvar Resizer = /** @class */ (function (_super) {\n    __extends(Resizer, _super);\n    function Resizer() {\n        var _this = _super !== null && _super.apply(this, arguments) || this;\n        _this.onMouseDown = function (e) {\n            _this.props.onResizeStart(e, _this.props.direction);\n        };\n        _this.onTouchStart = function (e) {\n            _this.props.onResizeStart(e, _this.props.direction);\n        };\n        return _this;\n    }\n    Resizer.prototype.render = function () {\n        return (React.createElement(\"div\", { className: this.props.className || '', style: __assign(__assign({ position: 'absolute', userSelect: 'none' }, styles[this.props.direction]), (this.props.replaceStyles || {})), onMouseDown: this.onMouseDown, onTouchStart: this.onTouchStart }, this.props.children));\n    };\n    return Resizer;\n}(React.PureComponent));\nexport { Resizer };\n","var __extends = (this && this.__extends) || (function () {\n    var extendStatics = function (d, b) {\n        extendStatics = Object.setPrototypeOf ||\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nvar __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nimport * as React from 'react';\nimport { flushSync } from 'react-dom';\nimport { Resizer } from './resizer';\nvar DEFAULT_SIZE = {\n    width: 'auto',\n    height: 'auto',\n};\nvar clamp = function (n, min, max) { return Math.max(Math.min(n, max), min); };\nvar snap = function (n, size) { return Math.round(n / size) * size; };\nvar hasDirection = function (dir, target) {\n    return new RegExp(dir, 'i').test(target);\n};\n// INFO: In case of window is a Proxy and does not porxy Events correctly, use isTouchEvent & isMouseEvent to distinguish event type instead of `instanceof`.\nvar isTouchEvent = function (event) {\n    return Boolean(event.touches && event.touches.length);\n};\nvar isMouseEvent = function (event) {\n    return Boolean((event.clientX || event.clientX === 0) &&\n        (event.clientY || event.clientY === 0));\n};\nvar findClosestSnap = function (n, snapArray, snapGap) {\n    if (snapGap === void 0) { snapGap = 0; }\n    var closestGapIndex = snapArray.reduce(function (prev, curr, index) { return (Math.abs(curr - n) < Math.abs(snapArray[prev] - n) ? index : prev); }, 0);\n    var gap = Math.abs(snapArray[closestGapIndex] - n);\n    return snapGap === 0 || gap < snapGap ? snapArray[closestGapIndex] : n;\n};\nvar getStringSize = function (n) {\n    n = n.toString();\n    if (n === 'auto') {\n        return n;\n    }\n    if (n.endsWith('px')) {\n        return n;\n    }\n    if (n.endsWith('%')) {\n        return n;\n    }\n    if (n.endsWith('vh')) {\n        return n;\n    }\n    if (n.endsWith('vw')) {\n        return n;\n    }\n    if (n.endsWith('vmax')) {\n        return n;\n    }\n    if (n.endsWith('vmin')) {\n        return n;\n    }\n    return n + \"px\";\n};\nvar getPixelSize = function (size, parentSize, innerWidth, innerHeight) {\n    if (size && typeof size === 'string') {\n        if (size.endsWith('px')) {\n            return Number(size.replace('px', ''));\n        }\n        if (size.endsWith('%')) {\n            var ratio = Number(size.replace('%', '')) / 100;\n            return parentSize * ratio;\n        }\n        if (size.endsWith('vw')) {\n            var ratio = Number(size.replace('vw', '')) / 100;\n            return innerWidth * ratio;\n        }\n        if (size.endsWith('vh')) {\n            var ratio = Number(size.replace('vh', '')) / 100;\n            return innerHeight * ratio;\n        }\n    }\n    return size;\n};\nvar calculateNewMax = function (parentSize, innerWidth, innerHeight, maxWidth, maxHeight, minWidth, minHeight) {\n    maxWidth = getPixelSize(maxWidth, parentSize.width, innerWidth, innerHeight);\n    maxHeight = getPixelSize(maxHeight, parentSize.height, innerWidth, innerHeight);\n    minWidth = getPixelSize(minWidth, parentSize.width, innerWidth, innerHeight);\n    minHeight = getPixelSize(minHeight, parentSize.height, innerWidth, innerHeight);\n    return {\n        maxWidth: typeof maxWidth === 'undefined' ? undefined : Number(maxWidth),\n        maxHeight: typeof maxHeight === 'undefined' ? undefined : Number(maxHeight),\n        minWidth: typeof minWidth === 'undefined' ? undefined : Number(minWidth),\n        minHeight: typeof minHeight === 'undefined' ? undefined : Number(minHeight),\n    };\n};\nvar definedProps = [\n    'as',\n    'style',\n    'className',\n    'grid',\n    'snap',\n    'bounds',\n    'boundsByDirection',\n    'size',\n    'defaultSize',\n    'minWidth',\n    'minHeight',\n    'maxWidth',\n    'maxHeight',\n    'lockAspectRatio',\n    'lockAspectRatioExtraWidth',\n    'lockAspectRatioExtraHeight',\n    'enable',\n    'handleStyles',\n    'handleClasses',\n    'handleWrapperStyle',\n    'handleWrapperClass',\n    'children',\n    'onResizeStart',\n    'onResize',\n    'onResizeStop',\n    'handleComponent',\n    'scale',\n    'resizeRatio',\n    'snapGap',\n];\n// HACK: This class is used to calculate % size.\nvar baseClassName = '__resizable_base__';\nvar Resizable = /** @class */ (function (_super) {\n    __extends(Resizable, _super);\n    function Resizable(props) {\n        var _this = _super.call(this, props) || this;\n        _this.ratio = 1;\n        _this.resizable = null;\n        // For parent boundary\n        _this.parentLeft = 0;\n        _this.parentTop = 0;\n        // For boundary\n        _this.resizableLeft = 0;\n        _this.resizableRight = 0;\n        _this.resizableTop = 0;\n        _this.resizableBottom = 0;\n        // For target boundary\n        _this.targetLeft = 0;\n        _this.targetTop = 0;\n        _this.appendBase = function () {\n            if (!_this.resizable || !_this.window) {\n                return null;\n            }\n            var parent = _this.parentNode;\n            if (!parent) {\n                return null;\n            }\n            var element = _this.window.document.createElement('div');\n            element.style.width = '100%';\n            element.style.height = '100%';\n            element.style.position = 'absolute';\n            element.style.transform = 'scale(0, 0)';\n            element.style.left = '0';\n            element.style.flex = '0 0 100%';\n            if (element.classList) {\n                element.classList.add(baseClassName);\n            }\n            else {\n                element.className += baseClassName;\n            }\n            parent.appendChild(element);\n            return element;\n        };\n        _this.removeBase = function (base) {\n            var parent = _this.parentNode;\n            if (!parent) {\n                return;\n            }\n            parent.removeChild(base);\n        };\n        _this.ref = function (c) {\n            if (c) {\n                _this.resizable = c;\n            }\n        };\n        _this.state = {\n            isResizing: false,\n            width: typeof (_this.propsSize && _this.propsSize.width) === 'undefined'\n                ? 'auto'\n                : _this.propsSize && _this.propsSize.width,\n            height: typeof (_this.propsSize && _this.propsSize.height) === 'undefined'\n                ? 'auto'\n                : _this.propsSize && _this.propsSize.height,\n            direction: 'right',\n            original: {\n                x: 0,\n                y: 0,\n                width: 0,\n                height: 0,\n            },\n            backgroundStyle: {\n                height: '100%',\n                width: '100%',\n                backgroundColor: 'rgba(0,0,0,0)',\n                cursor: 'auto',\n                opacity: 0,\n                position: 'fixed',\n                zIndex: 9999,\n                top: '0',\n                left: '0',\n                bottom: '0',\n                right: '0',\n            },\n            flexBasis: undefined,\n        };\n        _this.onResizeStart = _this.onResizeStart.bind(_this);\n        _this.onMouseMove = _this.onMouseMove.bind(_this);\n        _this.onMouseUp = _this.onMouseUp.bind(_this);\n        return _this;\n    }\n    Object.defineProperty(Resizable.prototype, \"parentNode\", {\n        get: function () {\n            if (!this.resizable) {\n                return null;\n            }\n            return this.resizable.parentNode;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(Resizable.prototype, \"window\", {\n        get: function () {\n            if (!this.resizable) {\n                return null;\n            }\n            if (!this.resizable.ownerDocument) {\n                return null;\n            }\n            return this.resizable.ownerDocument.defaultView;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(Resizable.prototype, \"propsSize\", {\n        get: function () {\n            return this.props.size || this.props.defaultSize || DEFAULT_SIZE;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(Resizable.prototype, \"size\", {\n        get: function () {\n            var width = 0;\n            var height = 0;\n            if (this.resizable && this.window) {\n                var orgWidth = this.resizable.offsetWidth;\n                var orgHeight = this.resizable.offsetHeight;\n                // HACK: Set position `relative` to get parent size.\n                //       This is because when re-resizable set `absolute`, I can not get base width correctly.\n                var orgPosition = this.resizable.style.position;\n                if (orgPosition !== 'relative') {\n                    this.resizable.style.position = 'relative';\n                }\n                // INFO: Use original width or height if set auto.\n                width = this.resizable.style.width !== 'auto' ? this.resizable.offsetWidth : orgWidth;\n                height = this.resizable.style.height !== 'auto' ? this.resizable.offsetHeight : orgHeight;\n                // Restore original position\n                this.resizable.style.position = orgPosition;\n            }\n            return { width: width, height: height };\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(Resizable.prototype, \"sizeStyle\", {\n        get: function () {\n            var _this = this;\n            var size = this.props.size;\n            var getSize = function (key) {\n                if (typeof _this.state[key] === 'undefined' || _this.state[key] === 'auto') {\n                    return 'auto';\n                }\n                if (_this.propsSize && _this.propsSize[key] && _this.propsSize[key].toString().endsWith('%')) {\n                    if (_this.state[key].toString().endsWith('%')) {\n                        return _this.state[key].toString();\n                    }\n                    var parentSize = _this.getParentSize();\n                    var value = Number(_this.state[key].toString().replace('px', ''));\n                    var percent = (value / parentSize[key]) * 100;\n                    return percent + \"%\";\n                }\n                return getStringSize(_this.state[key]);\n            };\n            var width = size && typeof size.width !== 'undefined' && !this.state.isResizing\n                ? getStringSize(size.width)\n                : getSize('width');\n            var height = size && typeof size.height !== 'undefined' && !this.state.isResizing\n                ? getStringSize(size.height)\n                : getSize('height');\n            return { width: width, height: height };\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Resizable.prototype.getParentSize = function () {\n        if (!this.parentNode) {\n            if (!this.window) {\n                return { width: 0, height: 0 };\n            }\n            return { width: this.window.innerWidth, height: this.window.innerHeight };\n        }\n        var base = this.appendBase();\n        if (!base) {\n            return { width: 0, height: 0 };\n        }\n        // INFO: To calculate parent width with flex layout\n        var wrapChanged = false;\n        var wrap = this.parentNode.style.flexWrap;\n        if (wrap !== 'wrap') {\n            wrapChanged = true;\n            this.parentNode.style.flexWrap = 'wrap';\n            // HACK: Use relative to get parent padding size\n        }\n        base.style.position = 'relative';\n        base.style.minWidth = '100%';\n        base.style.minHeight = '100%';\n        var size = {\n            width: base.offsetWidth,\n            height: base.offsetHeight,\n        };\n        if (wrapChanged) {\n            this.parentNode.style.flexWrap = wrap;\n        }\n        this.removeBase(base);\n        return size;\n    };\n    Resizable.prototype.bindEvents = function () {\n        if (this.window) {\n            this.window.addEventListener('mouseup', this.onMouseUp);\n            this.window.addEventListener('mousemove', this.onMouseMove);\n            this.window.addEventListener('mouseleave', this.onMouseUp);\n            this.window.addEventListener('touchmove', this.onMouseMove, {\n                capture: true,\n                passive: false,\n            });\n            this.window.addEventListener('touchend', this.onMouseUp);\n        }\n    };\n    Resizable.prototype.unbindEvents = function () {\n        if (this.window) {\n            this.window.removeEventListener('mouseup', this.onMouseUp);\n            this.window.removeEventListener('mousemove', this.onMouseMove);\n            this.window.removeEventListener('mouseleave', this.onMouseUp);\n            this.window.removeEventListener('touchmove', this.onMouseMove, true);\n            this.window.removeEventListener('touchend', this.onMouseUp);\n        }\n    };\n    Resizable.prototype.componentDidMount = function () {\n        if (!this.resizable || !this.window) {\n            return;\n        }\n        var computedStyle = this.window.getComputedStyle(this.resizable);\n        this.setState({\n            width: this.state.width || this.size.width,\n            height: this.state.height || this.size.height,\n            flexBasis: computedStyle.flexBasis !== 'auto' ? computedStyle.flexBasis : undefined,\n        });\n    };\n    Resizable.prototype.componentWillUnmount = function () {\n        if (this.window) {\n            this.unbindEvents();\n        }\n    };\n    Resizable.prototype.createSizeForCssProperty = function (newSize, kind) {\n        var propsSize = this.propsSize && this.propsSize[kind];\n        return this.state[kind] === 'auto' &&\n            this.state.original[kind] === newSize &&\n            (typeof propsSize === 'undefined' || propsSize === 'auto')\n            ? 'auto'\n            : newSize;\n    };\n    Resizable.prototype.calculateNewMaxFromBoundary = function (maxWidth, maxHeight) {\n        var boundsByDirection = this.props.boundsByDirection;\n        var direction = this.state.direction;\n        var widthByDirection = boundsByDirection && hasDirection('left', direction);\n        var heightByDirection = boundsByDirection && hasDirection('top', direction);\n        var boundWidth;\n        var boundHeight;\n        if (this.props.bounds === 'parent') {\n            var parent_1 = this.parentNode;\n            if (parent_1) {\n                boundWidth = widthByDirection\n                    ? this.resizableRight - this.parentLeft\n                    : parent_1.offsetWidth + (this.parentLeft - this.resizableLeft);\n                boundHeight = heightByDirection\n                    ? this.resizableBottom - this.parentTop\n                    : parent_1.offsetHeight + (this.parentTop - this.resizableTop);\n            }\n        }\n        else if (this.props.bounds === 'window') {\n            if (this.window) {\n                boundWidth = widthByDirection ? this.resizableRight : this.window.innerWidth - this.resizableLeft;\n                boundHeight = heightByDirection ? this.resizableBottom : this.window.innerHeight - this.resizableTop;\n            }\n        }\n        else if (this.props.bounds) {\n            boundWidth = widthByDirection\n                ? this.resizableRight - this.targetLeft\n                : this.props.bounds.offsetWidth + (this.targetLeft - this.resizableLeft);\n            boundHeight = heightByDirection\n                ? this.resizableBottom - this.targetTop\n                : this.props.bounds.offsetHeight + (this.targetTop - this.resizableTop);\n        }\n        if (boundWidth && Number.isFinite(boundWidth)) {\n            maxWidth = maxWidth && maxWidth < boundWidth ? maxWidth : boundWidth;\n        }\n        if (boundHeight && Number.isFinite(boundHeight)) {\n            maxHeight = maxHeight && maxHeight < boundHeight ? maxHeight : boundHeight;\n        }\n        return { maxWidth: maxWidth, maxHeight: maxHeight };\n    };\n    Resizable.prototype.calculateNewSizeFromDirection = function (clientX, clientY) {\n        var scale = this.props.scale || 1;\n        var resizeRatio = this.props.resizeRatio || 1;\n        var _a = this.state, direction = _a.direction, original = _a.original;\n        var _b = this.props, lockAspectRatio = _b.lockAspectRatio, lockAspectRatioExtraHeight = _b.lockAspectRatioExtraHeight, lockAspectRatioExtraWidth = _b.lockAspectRatioExtraWidth;\n        var newWidth = original.width;\n        var newHeight = original.height;\n        var extraHeight = lockAspectRatioExtraHeight || 0;\n        var extraWidth = lockAspectRatioExtraWidth || 0;\n        if (hasDirection('right', direction)) {\n            newWidth = original.width + ((clientX - original.x) * resizeRatio) / scale;\n            if (lockAspectRatio) {\n                newHeight = (newWidth - extraWidth) / this.ratio + extraHeight;\n            }\n        }\n        if (hasDirection('left', direction)) {\n            newWidth = original.width - ((clientX - original.x) * resizeRatio) / scale;\n            if (lockAspectRatio) {\n                newHeight = (newWidth - extraWidth) / this.ratio + extraHeight;\n            }\n        }\n        if (hasDirection('bottom', direction)) {\n            newHeight = original.height + ((clientY - original.y) * resizeRatio) / scale;\n            if (lockAspectRatio) {\n                newWidth = (newHeight - extraHeight) * this.ratio + extraWidth;\n            }\n        }\n        if (hasDirection('top', direction)) {\n            newHeight = original.height - ((clientY - original.y) * resizeRatio) / scale;\n            if (lockAspectRatio) {\n                newWidth = (newHeight - extraHeight) * this.ratio + extraWidth;\n            }\n        }\n        return { newWidth: newWidth, newHeight: newHeight };\n    };\n    Resizable.prototype.calculateNewSizeFromAspectRatio = function (newWidth, newHeight, max, min) {\n        var _a = this.props, lockAspectRatio = _a.lockAspectRatio, lockAspectRatioExtraHeight = _a.lockAspectRatioExtraHeight, lockAspectRatioExtraWidth = _a.lockAspectRatioExtraWidth;\n        var computedMinWidth = typeof min.width === 'undefined' ? 10 : min.width;\n        var computedMaxWidth = typeof max.width === 'undefined' || max.width < 0 ? newWidth : max.width;\n        var computedMinHeight = typeof min.height === 'undefined' ? 10 : min.height;\n        var computedMaxHeight = typeof max.height === 'undefined' || max.height < 0 ? newHeight : max.height;\n        var extraHeight = lockAspectRatioExtraHeight || 0;\n        var extraWidth = lockAspectRatioExtraWidth || 0;\n        if (lockAspectRatio) {\n            var extraMinWidth = (computedMinHeight - extraHeight) * this.ratio + extraWidth;\n            var extraMaxWidth = (computedMaxHeight - extraHeight) * this.ratio + extraWidth;\n            var extraMinHeight = (computedMinWidth - extraWidth) / this.ratio + extraHeight;\n            var extraMaxHeight = (computedMaxWidth - extraWidth) / this.ratio + extraHeight;\n            var lockedMinWidth = Math.max(computedMinWidth, extraMinWidth);\n            var lockedMaxWidth = Math.min(computedMaxWidth, extraMaxWidth);\n            var lockedMinHeight = Math.max(computedMinHeight, extraMinHeight);\n            var lockedMaxHeight = Math.min(computedMaxHeight, extraMaxHeight);\n            newWidth = clamp(newWidth, lockedMinWidth, lockedMaxWidth);\n            newHeight = clamp(newHeight, lockedMinHeight, lockedMaxHeight);\n        }\n        else {\n            newWidth = clamp(newWidth, computedMinWidth, computedMaxWidth);\n            newHeight = clamp(newHeight, computedMinHeight, computedMaxHeight);\n        }\n        return { newWidth: newWidth, newHeight: newHeight };\n    };\n    Resizable.prototype.setBoundingClientRect = function () {\n        // For parent boundary\n        if (this.props.bounds === 'parent') {\n            var parent_2 = this.parentNode;\n            if (parent_2) {\n                var parentRect = parent_2.getBoundingClientRect();\n                this.parentLeft = parentRect.left;\n                this.parentTop = parentRect.top;\n            }\n        }\n        // For target(html element) boundary\n        if (this.props.bounds && typeof this.props.bounds !== 'string') {\n            var targetRect = this.props.bounds.getBoundingClientRect();\n            this.targetLeft = targetRect.left;\n            this.targetTop = targetRect.top;\n        }\n        // For boundary\n        if (this.resizable) {\n            var _a = this.resizable.getBoundingClientRect(), left = _a.left, top_1 = _a.top, right = _a.right, bottom = _a.bottom;\n            this.resizableLeft = left;\n            this.resizableRight = right;\n            this.resizableTop = top_1;\n            this.resizableBottom = bottom;\n        }\n    };\n    Resizable.prototype.onResizeStart = function (event, direction) {\n        if (!this.resizable || !this.window) {\n            return;\n        }\n        var clientX = 0;\n        var clientY = 0;\n        if (event.nativeEvent && isMouseEvent(event.nativeEvent)) {\n            clientX = event.nativeEvent.clientX;\n            clientY = event.nativeEvent.clientY;\n        }\n        else if (event.nativeEvent && isTouchEvent(event.nativeEvent)) {\n            clientX = event.nativeEvent.touches[0].clientX;\n            clientY = event.nativeEvent.touches[0].clientY;\n        }\n        if (this.props.onResizeStart) {\n            if (this.resizable) {\n                var startResize = this.props.onResizeStart(event, direction, this.resizable);\n                if (startResize === false) {\n                    return;\n                }\n            }\n        }\n        // Fix #168\n        if (this.props.size) {\n            if (typeof this.props.size.height !== 'undefined' && this.props.size.height !== this.state.height) {\n                this.setState({ height: this.props.size.height });\n            }\n            if (typeof this.props.size.width !== 'undefined' && this.props.size.width !== this.state.width) {\n                this.setState({ width: this.props.size.width });\n            }\n        }\n        // For lockAspectRatio case\n        this.ratio =\n            typeof this.props.lockAspectRatio === 'number' ? this.props.lockAspectRatio : this.size.width / this.size.height;\n        var flexBasis;\n        var computedStyle = this.window.getComputedStyle(this.resizable);\n        if (computedStyle.flexBasis !== 'auto') {\n            var parent_3 = this.parentNode;\n            if (parent_3) {\n                var dir = this.window.getComputedStyle(parent_3).flexDirection;\n                this.flexDir = dir.startsWith('row') ? 'row' : 'column';\n                flexBasis = computedStyle.flexBasis;\n            }\n        }\n        // For boundary\n        this.setBoundingClientRect();\n        this.bindEvents();\n        var state = {\n            original: {\n                x: clientX,\n                y: clientY,\n                width: this.size.width,\n                height: this.size.height,\n            },\n            isResizing: true,\n            backgroundStyle: __assign(__assign({}, this.state.backgroundStyle), { cursor: this.window.getComputedStyle(event.target).cursor || 'auto' }),\n            direction: direction,\n            flexBasis: flexBasis,\n        };\n        this.setState(state);\n    };\n    Resizable.prototype.onMouseMove = function (event) {\n        var _this = this;\n        if (!this.state.isResizing || !this.resizable || !this.window) {\n            return;\n        }\n        if (this.window.TouchEvent && isTouchEvent(event)) {\n            try {\n                event.preventDefault();\n                event.stopPropagation();\n            }\n            catch (e) {\n                // Ignore on fail\n            }\n        }\n        var _a = this.props, maxWidth = _a.maxWidth, maxHeight = _a.maxHeight, minWidth = _a.minWidth, minHeight = _a.minHeight;\n        var clientX = isTouchEvent(event) ? event.touches[0].clientX : event.clientX;\n        var clientY = isTouchEvent(event) ? event.touches[0].clientY : event.clientY;\n        var _b = this.state, direction = _b.direction, original = _b.original, width = _b.width, height = _b.height;\n        var parentSize = this.getParentSize();\n        var max = calculateNewMax(parentSize, this.window.innerWidth, this.window.innerHeight, maxWidth, maxHeight, minWidth, minHeight);\n        maxWidth = max.maxWidth;\n        maxHeight = max.maxHeight;\n        minWidth = max.minWidth;\n        minHeight = max.minHeight;\n        // Calculate new size\n        var _c = this.calculateNewSizeFromDirection(clientX, clientY), newHeight = _c.newHeight, newWidth = _c.newWidth;\n        // Calculate max size from boundary settings\n        var boundaryMax = this.calculateNewMaxFromBoundary(maxWidth, maxHeight);\n        if (this.props.snap && this.props.snap.x) {\n            newWidth = findClosestSnap(newWidth, this.props.snap.x, this.props.snapGap);\n        }\n        if (this.props.snap && this.props.snap.y) {\n            newHeight = findClosestSnap(newHeight, this.props.snap.y, this.props.snapGap);\n        }\n        // Calculate new size from aspect ratio\n        var newSize = this.calculateNewSizeFromAspectRatio(newWidth, newHeight, { width: boundaryMax.maxWidth, height: boundaryMax.maxHeight }, { width: minWidth, height: minHeight });\n        newWidth = newSize.newWidth;\n        newHeight = newSize.newHeight;\n        if (this.props.grid) {\n            var newGridWidth = snap(newWidth, this.props.grid[0]);\n            var newGridHeight = snap(newHeight, this.props.grid[1]);\n            var gap = this.props.snapGap || 0;\n            newWidth = gap === 0 || Math.abs(newGridWidth - newWidth) <= gap ? newGridWidth : newWidth;\n            newHeight = gap === 0 || Math.abs(newGridHeight - newHeight) <= gap ? newGridHeight : newHeight;\n        }\n        var delta = {\n            width: newWidth - original.width,\n            height: newHeight - original.height,\n        };\n        if (width && typeof width === 'string') {\n            if (width.endsWith('%')) {\n                var percent = (newWidth / parentSize.width) * 100;\n                newWidth = percent + \"%\";\n            }\n            else if (width.endsWith('vw')) {\n                var vw = (newWidth / this.window.innerWidth) * 100;\n                newWidth = vw + \"vw\";\n            }\n            else if (width.endsWith('vh')) {\n                var vh = (newWidth / this.window.innerHeight) * 100;\n                newWidth = vh + \"vh\";\n            }\n        }\n        if (height && typeof height === 'string') {\n            if (height.endsWith('%')) {\n                var percent = (newHeight / parentSize.height) * 100;\n                newHeight = percent + \"%\";\n            }\n            else if (height.endsWith('vw')) {\n                var vw = (newHeight / this.window.innerWidth) * 100;\n                newHeight = vw + \"vw\";\n            }\n            else if (height.endsWith('vh')) {\n                var vh = (newHeight / this.window.innerHeight) * 100;\n                newHeight = vh + \"vh\";\n            }\n        }\n        var newState = {\n            width: this.createSizeForCssProperty(newWidth, 'width'),\n            height: this.createSizeForCssProperty(newHeight, 'height'),\n        };\n        if (this.flexDir === 'row') {\n            newState.flexBasis = newState.width;\n        }\n        else if (this.flexDir === 'column') {\n            newState.flexBasis = newState.height;\n        }\n        // For v18, update state sync\n        flushSync(function () {\n            _this.setState(newState);\n        });\n        if (this.props.onResize) {\n            this.props.onResize(event, direction, this.resizable, delta);\n        }\n    };\n    Resizable.prototype.onMouseUp = function (event) {\n        var _a = this.state, isResizing = _a.isResizing, direction = _a.direction, original = _a.original;\n        if (!isResizing || !this.resizable) {\n            return;\n        }\n        var delta = {\n            width: this.size.width - original.width,\n            height: this.size.height - original.height,\n        };\n        if (this.props.onResizeStop) {\n            this.props.onResizeStop(event, direction, this.resizable, delta);\n        }\n        if (this.props.size) {\n            this.setState(this.props.size);\n        }\n        this.unbindEvents();\n        this.setState({\n            isResizing: false,\n            backgroundStyle: __assign(__assign({}, this.state.backgroundStyle), { cursor: 'auto' }),\n        });\n    };\n    Resizable.prototype.updateSize = function (size) {\n        this.setState({ width: size.width, height: size.height });\n    };\n    Resizable.prototype.renderResizer = function () {\n        var _this = this;\n        var _a = this.props, enable = _a.enable, handleStyles = _a.handleStyles, handleClasses = _a.handleClasses, handleWrapperStyle = _a.handleWrapperStyle, handleWrapperClass = _a.handleWrapperClass, handleComponent = _a.handleComponent;\n        if (!enable) {\n            return null;\n        }\n        var resizers = Object.keys(enable).map(function (dir) {\n            if (enable[dir] !== false) {\n                return (React.createElement(Resizer, { key: dir, direction: dir, onResizeStart: _this.onResizeStart, replaceStyles: handleStyles && handleStyles[dir], className: handleClasses && handleClasses[dir] }, handleComponent && handleComponent[dir] ? handleComponent[dir] : null));\n            }\n            return null;\n        });\n        // #93 Wrap the resize box in span (will not break 100% width/height)\n        return (React.createElement(\"div\", { className: handleWrapperClass, style: handleWrapperStyle }, resizers));\n    };\n    Resizable.prototype.render = function () {\n        var _this = this;\n        var extendsProps = Object.keys(this.props).reduce(function (acc, key) {\n            if (definedProps.indexOf(key) !== -1) {\n                return acc;\n            }\n            acc[key] = _this.props[key];\n            return acc;\n        }, {});\n        var style = __assign(__assign(__assign({ position: 'relative', userSelect: this.state.isResizing ? 'none' : 'auto' }, this.props.style), this.sizeStyle), { maxWidth: this.props.maxWidth, maxHeight: this.props.maxHeight, minWidth: this.props.minWidth, minHeight: this.props.minHeight, boxSizing: 'border-box', flexShrink: 0 });\n        if (this.state.flexBasis) {\n            style.flexBasis = this.state.flexBasis;\n        }\n        var Wrapper = this.props.as || 'div';\n        return (React.createElement(Wrapper, __assign({ ref: this.ref, style: style, className: this.props.className }, extendsProps),\n            this.state.isResizing && React.createElement(\"div\", { style: this.state.backgroundStyle }),\n            this.props.children,\n            this.renderResizer()));\n    };\n    Resizable.defaultProps = {\n        as: 'div',\n        onResizeStart: function () { },\n        onResize: function () { },\n        onResizeStop: function () { },\n        enable: {\n            top: true,\n            right: true,\n            bottom: true,\n            left: true,\n            topRight: true,\n            bottomRight: true,\n            bottomLeft: true,\n            topLeft: true,\n        },\n        style: {},\n        grid: [1, 1],\n        lockAspectRatio: false,\n        lockAspectRatioExtraWidth: 0,\n        lockAspectRatioExtraHeight: 0,\n        scale: 1,\n        resizeRatio: 1,\n        snapGap: 0,\n    };\n    return Resizable;\n}(React.PureComponent));\nexport { Resizable };\n","/** @license React v17.0.2\n * react-dom-server.browser.production.min.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n'use strict';var l=require(\"object-assign\"),m=require(\"react\");function p(a){for(var b=\"https://reactjs.org/docs/error-decoder.html?invariant=\"+a,c=1;c<arguments.length;c++)b+=\"&args[]=\"+encodeURIComponent(arguments[c]);return\"Minified React error #\"+a+\"; visit \"+b+\" for the full message or use the non-minified dev environment for full errors and additional helpful warnings.\"}\nvar q=60106,r=60107,u=60108,z=60114,B=60109,aa=60110,ba=60112,D=60113,ca=60120,da=60115,ea=60116,fa=60121,ha=60117,ia=60119,ja=60129,ka=60131;\nif(\"function\"===typeof Symbol&&Symbol.for){var E=Symbol.for;q=E(\"react.portal\");r=E(\"react.fragment\");u=E(\"react.strict_mode\");z=E(\"react.profiler\");B=E(\"react.provider\");aa=E(\"react.context\");ba=E(\"react.forward_ref\");D=E(\"react.suspense\");ca=E(\"react.suspense_list\");da=E(\"react.memo\");ea=E(\"react.lazy\");fa=E(\"react.block\");ha=E(\"react.fundamental\");ia=E(\"react.scope\");ja=E(\"react.debug_trace_mode\");ka=E(\"react.legacy_hidden\")}\nfunction F(a){if(null==a)return null;if(\"function\"===typeof a)return a.displayName||a.name||null;if(\"string\"===typeof a)return a;switch(a){case r:return\"Fragment\";case q:return\"Portal\";case z:return\"Profiler\";case u:return\"StrictMode\";case D:return\"Suspense\";case ca:return\"SuspenseList\"}if(\"object\"===typeof a)switch(a.$$typeof){case aa:return(a.displayName||\"Context\")+\".Consumer\";case B:return(a._context.displayName||\"Context\")+\".Provider\";case ba:var b=a.render;b=b.displayName||b.name||\"\";return a.displayName||\n(\"\"!==b?\"ForwardRef(\"+b+\")\":\"ForwardRef\");case da:return F(a.type);case fa:return F(a._render);case ea:b=a._payload;a=a._init;try{return F(a(b))}catch(c){}}return null}var la=m.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED,ma={};function I(a,b){for(var c=a._threadCount|0;c<=b;c++)a[c]=a._currentValue2,a._threadCount=c+1}function na(a,b,c,d){if(d&&(d=a.contextType,\"object\"===typeof d&&null!==d))return I(d,c),d[c];if(a=a.contextTypes){c={};for(var f in a)c[f]=b[f];b=c}else b=ma;return b}\nfor(var J=new Uint16Array(16),K=0;15>K;K++)J[K]=K+1;J[15]=0;var oa=/^[:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD][:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040]*$/,pa=Object.prototype.hasOwnProperty,qa={},ra={};\nfunction sa(a){if(pa.call(ra,a))return!0;if(pa.call(qa,a))return!1;if(oa.test(a))return ra[a]=!0;qa[a]=!0;return!1}function ta(a,b,c,d){if(null!==c&&0===c.type)return!1;switch(typeof b){case \"function\":case \"symbol\":return!0;case \"boolean\":if(d)return!1;if(null!==c)return!c.acceptsBooleans;a=a.toLowerCase().slice(0,5);return\"data-\"!==a&&\"aria-\"!==a;default:return!1}}\nfunction ua(a,b,c,d){if(null===b||\"undefined\"===typeof b||ta(a,b,c,d))return!0;if(d)return!1;if(null!==c)switch(c.type){case 3:return!b;case 4:return!1===b;case 5:return isNaN(b);case 6:return isNaN(b)||1>b}return!1}function M(a,b,c,d,f,h,t){this.acceptsBooleans=2===b||3===b||4===b;this.attributeName=d;this.attributeNamespace=f;this.mustUseProperty=c;this.propertyName=a;this.type=b;this.sanitizeURL=h;this.removeEmptyString=t}var N={};\n\"children dangerouslySetInnerHTML defaultValue defaultChecked innerHTML suppressContentEditableWarning suppressHydrationWarning style\".split(\" \").forEach(function(a){N[a]=new M(a,0,!1,a,null,!1,!1)});[[\"acceptCharset\",\"accept-charset\"],[\"className\",\"class\"],[\"htmlFor\",\"for\"],[\"httpEquiv\",\"http-equiv\"]].forEach(function(a){var b=a[0];N[b]=new M(b,1,!1,a[1],null,!1,!1)});[\"contentEditable\",\"draggable\",\"spellCheck\",\"value\"].forEach(function(a){N[a]=new M(a,2,!1,a.toLowerCase(),null,!1,!1)});\n[\"autoReverse\",\"externalResourcesRequired\",\"focusable\",\"preserveAlpha\"].forEach(function(a){N[a]=new M(a,2,!1,a,null,!1,!1)});\"allowFullScreen async autoFocus autoPlay controls default defer disabled disablePictureInPicture disableRemotePlayback formNoValidate hidden loop noModule noValidate open playsInline readOnly required reversed scoped seamless itemScope\".split(\" \").forEach(function(a){N[a]=new M(a,3,!1,a.toLowerCase(),null,!1,!1)});\n[\"checked\",\"multiple\",\"muted\",\"selected\"].forEach(function(a){N[a]=new M(a,3,!0,a,null,!1,!1)});[\"capture\",\"download\"].forEach(function(a){N[a]=new M(a,4,!1,a,null,!1,!1)});[\"cols\",\"rows\",\"size\",\"span\"].forEach(function(a){N[a]=new M(a,6,!1,a,null,!1,!1)});[\"rowSpan\",\"start\"].forEach(function(a){N[a]=new M(a,5,!1,a.toLowerCase(),null,!1,!1)});var va=/[\\-:]([a-z])/g;function wa(a){return a[1].toUpperCase()}\n\"accent-height alignment-baseline arabic-form baseline-shift cap-height clip-path clip-rule color-interpolation color-interpolation-filters color-profile color-rendering dominant-baseline enable-background fill-opacity fill-rule flood-color flood-opacity font-family font-size font-size-adjust font-stretch font-style font-variant font-weight glyph-name glyph-orientation-horizontal glyph-orientation-vertical horiz-adv-x horiz-origin-x image-rendering letter-spacing lighting-color marker-end marker-mid marker-start overline-position overline-thickness paint-order panose-1 pointer-events rendering-intent shape-rendering stop-color stop-opacity strikethrough-position strikethrough-thickness stroke-dasharray stroke-dashoffset stroke-linecap stroke-linejoin stroke-miterlimit stroke-opacity stroke-width text-anchor text-decoration text-rendering underline-position underline-thickness unicode-bidi unicode-range units-per-em v-alphabetic v-hanging v-ideographic v-mathematical vector-effect vert-adv-y vert-origin-x vert-origin-y word-spacing writing-mode xmlns:xlink x-height\".split(\" \").forEach(function(a){var b=a.replace(va,\nwa);N[b]=new M(b,1,!1,a,null,!1,!1)});\"xlink:actuate xlink:arcrole xlink:role xlink:show xlink:title xlink:type\".split(\" \").forEach(function(a){var b=a.replace(va,wa);N[b]=new M(b,1,!1,a,\"http://www.w3.org/1999/xlink\",!1,!1)});[\"xml:base\",\"xml:lang\",\"xml:space\"].forEach(function(a){var b=a.replace(va,wa);N[b]=new M(b,1,!1,a,\"http://www.w3.org/XML/1998/namespace\",!1,!1)});[\"tabIndex\",\"crossOrigin\"].forEach(function(a){N[a]=new M(a,1,!1,a.toLowerCase(),null,!1,!1)});\nN.xlinkHref=new M(\"xlinkHref\",1,!1,\"xlink:href\",\"http://www.w3.org/1999/xlink\",!0,!1);[\"src\",\"href\",\"action\",\"formAction\"].forEach(function(a){N[a]=new M(a,1,!1,a.toLowerCase(),null,!0,!0)});var xa=/[\"'&<>]/;\nfunction O(a){if(\"boolean\"===typeof a||\"number\"===typeof a)return\"\"+a;a=\"\"+a;var b=xa.exec(a);if(b){var c=\"\",d,f=0;for(d=b.index;d<a.length;d++){switch(a.charCodeAt(d)){case 34:b=\"&quot;\";break;case 38:b=\"&amp;\";break;case 39:b=\"&#x27;\";break;case 60:b=\"&lt;\";break;case 62:b=\"&gt;\";break;default:continue}f!==d&&(c+=a.substring(f,d));f=d+1;c+=b}a=f!==d?c+a.substring(f,d):c}return a}\nfunction ya(a,b){var c=N.hasOwnProperty(a)?N[a]:null;var d;if(d=\"style\"!==a)d=null!==c?0===c.type:!(2<a.length)||\"o\"!==a[0]&&\"O\"!==a[0]||\"n\"!==a[1]&&\"N\"!==a[1]?!1:!0;if(d||ua(a,b,c,!1))return\"\";if(null!==c){a=c.attributeName;d=c.type;if(3===d||4===d&&!0===b)return a+'=\"\"';c.sanitizeURL&&(b=\"\"+b);return a+'=\"'+(O(b)+'\"')}return sa(a)?a+'=\"'+(O(b)+'\"'):\"\"}function za(a,b){return a===b&&(0!==a||1/a===1/b)||a!==a&&b!==b}\nvar Aa=\"function\"===typeof Object.is?Object.is:za,P=null,Q=null,R=null,S=!1,T=!1,U=null,V=0;function W(){if(null===P)throw Error(p(321));return P}function Ba(){if(0<V)throw Error(p(312));return{memoizedState:null,queue:null,next:null}}function Ca(){null===R?null===Q?(S=!1,Q=R=Ba()):(S=!0,R=Q):null===R.next?(S=!1,R=R.next=Ba()):(S=!0,R=R.next);return R}function Da(a,b,c,d){for(;T;)T=!1,V+=1,R=null,c=a(b,d);Ea();return c}function Ea(){P=null;T=!1;Q=null;V=0;R=U=null}\nfunction Fa(a,b){return\"function\"===typeof b?b(a):b}function Ga(a,b,c){P=W();R=Ca();if(S){var d=R.queue;b=d.dispatch;if(null!==U&&(c=U.get(d),void 0!==c)){U.delete(d);d=R.memoizedState;do d=a(d,c.action),c=c.next;while(null!==c);R.memoizedState=d;return[d,b]}return[R.memoizedState,b]}a=a===Fa?\"function\"===typeof b?b():b:void 0!==c?c(b):b;R.memoizedState=a;a=R.queue={last:null,dispatch:null};a=a.dispatch=Ha.bind(null,P,a);return[R.memoizedState,a]}\nfunction Ia(a,b){P=W();R=Ca();b=void 0===b?null:b;if(null!==R){var c=R.memoizedState;if(null!==c&&null!==b){var d=c[1];a:if(null===d)d=!1;else{for(var f=0;f<d.length&&f<b.length;f++)if(!Aa(b[f],d[f])){d=!1;break a}d=!0}if(d)return c[0]}}a=a();R.memoizedState=[a,b];return a}function Ha(a,b,c){if(!(25>V))throw Error(p(301));if(a===P)if(T=!0,a={action:c,next:null},null===U&&(U=new Map),c=U.get(b),void 0===c)U.set(b,a);else{for(b=c;null!==b.next;)b=b.next;b.next=a}}function Ja(){}\nvar X=null,Ka={readContext:function(a){var b=X.threadID;I(a,b);return a[b]},useContext:function(a){W();var b=X.threadID;I(a,b);return a[b]},useMemo:Ia,useReducer:Ga,useRef:function(a){P=W();R=Ca();var b=R.memoizedState;return null===b?(a={current:a},R.memoizedState=a):b},useState:function(a){return Ga(Fa,a)},useLayoutEffect:function(){},useCallback:function(a,b){return Ia(function(){return a},b)},useImperativeHandle:Ja,useEffect:Ja,useDebugValue:Ja,useDeferredValue:function(a){W();return a},useTransition:function(){W();\nreturn[function(a){a()},!1]},useOpaqueIdentifier:function(){return(X.identifierPrefix||\"\")+\"R:\"+(X.uniqueID++).toString(36)},useMutableSource:function(a,b){W();return b(a._source)}},La={html:\"http://www.w3.org/1999/xhtml\",mathml:\"http://www.w3.org/1998/Math/MathML\",svg:\"http://www.w3.org/2000/svg\"};function Ma(a){switch(a){case \"svg\":return\"http://www.w3.org/2000/svg\";case \"math\":return\"http://www.w3.org/1998/Math/MathML\";default:return\"http://www.w3.org/1999/xhtml\"}}\nvar Na={area:!0,base:!0,br:!0,col:!0,embed:!0,hr:!0,img:!0,input:!0,keygen:!0,link:!0,meta:!0,param:!0,source:!0,track:!0,wbr:!0},Oa=l({menuitem:!0},Na),Y={animationIterationCount:!0,borderImageOutset:!0,borderImageSlice:!0,borderImageWidth:!0,boxFlex:!0,boxFlexGroup:!0,boxOrdinalGroup:!0,columnCount:!0,columns:!0,flex:!0,flexGrow:!0,flexPositive:!0,flexShrink:!0,flexNegative:!0,flexOrder:!0,gridArea:!0,gridRow:!0,gridRowEnd:!0,gridRowSpan:!0,gridRowStart:!0,gridColumn:!0,gridColumnEnd:!0,gridColumnSpan:!0,\ngridColumnStart:!0,fontWeight:!0,lineClamp:!0,lineHeight:!0,opacity:!0,order:!0,orphans:!0,tabSize:!0,widows:!0,zIndex:!0,zoom:!0,fillOpacity:!0,floodOpacity:!0,stopOpacity:!0,strokeDasharray:!0,strokeDashoffset:!0,strokeMiterlimit:!0,strokeOpacity:!0,strokeWidth:!0},Pa=[\"Webkit\",\"ms\",\"Moz\",\"O\"];Object.keys(Y).forEach(function(a){Pa.forEach(function(b){b=b+a.charAt(0).toUpperCase()+a.substring(1);Y[b]=Y[a]})});\nvar Qa=/([A-Z])/g,Ra=/^ms-/,Z=m.Children.toArray,Sa=la.ReactCurrentDispatcher,Ta={listing:!0,pre:!0,textarea:!0},Ua=/^[a-zA-Z][a-zA-Z:_\\.\\-\\d]*$/,Va={},Wa={};function Xa(a){if(void 0===a||null===a)return a;var b=\"\";m.Children.forEach(a,function(a){null!=a&&(b+=a)});return b}var Ya=Object.prototype.hasOwnProperty,Za={children:null,dangerouslySetInnerHTML:null,suppressContentEditableWarning:null,suppressHydrationWarning:null};function $a(a,b){if(void 0===a)throw Error(p(152,F(b)||\"Component\"));}\nfunction ab(a,b,c){function d(d,h){var e=h.prototype&&h.prototype.isReactComponent,f=na(h,b,c,e),t=[],g=!1,n={isMounted:function(){return!1},enqueueForceUpdate:function(){if(null===t)return null},enqueueReplaceState:function(a,c){g=!0;t=[c]},enqueueSetState:function(a,c){if(null===t)return null;t.push(c)}};if(e){if(e=new h(d.props,f,n),\"function\"===typeof h.getDerivedStateFromProps){var k=h.getDerivedStateFromProps.call(null,d.props,e.state);null!=k&&(e.state=l({},e.state,k))}}else if(P={},e=h(d.props,\nf,n),e=Da(h,d.props,e,f),null==e||null==e.render){a=e;$a(a,h);return}e.props=d.props;e.context=f;e.updater=n;n=e.state;void 0===n&&(e.state=n=null);if(\"function\"===typeof e.UNSAFE_componentWillMount||\"function\"===typeof e.componentWillMount)if(\"function\"===typeof e.componentWillMount&&\"function\"!==typeof h.getDerivedStateFromProps&&e.componentWillMount(),\"function\"===typeof e.UNSAFE_componentWillMount&&\"function\"!==typeof h.getDerivedStateFromProps&&e.UNSAFE_componentWillMount(),t.length){n=t;var v=\ng;t=null;g=!1;if(v&&1===n.length)e.state=n[0];else{k=v?n[0]:e.state;var H=!0;for(v=v?1:0;v<n.length;v++){var x=n[v];x=\"function\"===typeof x?x.call(e,k,d.props,f):x;null!=x&&(H?(H=!1,k=l({},k,x)):l(k,x))}e.state=k}}else t=null;a=e.render();$a(a,h);if(\"function\"===typeof e.getChildContext&&(d=h.childContextTypes,\"object\"===typeof d)){var y=e.getChildContext();for(var A in y)if(!(A in d))throw Error(p(108,F(h)||\"Unknown\",A));}y&&(b=l({},b,y))}for(;m.isValidElement(a);){var f=a,h=f.type;if(\"function\"!==\ntypeof h)break;d(f,h)}return{child:a,context:b}}\nvar bb=function(){function a(a,b,f){m.isValidElement(a)?a.type!==r?a=[a]:(a=a.props.children,a=m.isValidElement(a)?[a]:Z(a)):a=Z(a);a={type:null,domNamespace:La.html,children:a,childIndex:0,context:ma,footer:\"\"};var c=J[0];if(0===c){var d=J;c=d.length;var g=2*c;if(!(65536>=g))throw Error(p(304));var e=new Uint16Array(g);e.set(d);J=e;J[0]=c+1;for(d=c;d<g-1;d++)J[d]=d+1;J[g-1]=0}else J[0]=J[c];this.threadID=c;this.stack=[a];this.exhausted=!1;this.currentSelectValue=null;this.previousWasTextNode=!1;\nthis.makeStaticMarkup=b;this.suspenseDepth=0;this.contextIndex=-1;this.contextStack=[];this.contextValueStack=[];this.uniqueID=0;this.identifierPrefix=f&&f.identifierPrefix||\"\"}var b=a.prototype;b.destroy=function(){if(!this.exhausted){this.exhausted=!0;this.clearProviders();var a=this.threadID;J[a]=J[0];J[0]=a}};b.pushProvider=function(a){var b=++this.contextIndex,c=a.type._context,h=this.threadID;I(c,h);var t=c[h];this.contextStack[b]=c;this.contextValueStack[b]=t;c[h]=a.props.value};b.popProvider=\nfunction(){var a=this.contextIndex,b=this.contextStack[a],f=this.contextValueStack[a];this.contextStack[a]=null;this.contextValueStack[a]=null;this.contextIndex--;b[this.threadID]=f};b.clearProviders=function(){for(var a=this.contextIndex;0<=a;a--)this.contextStack[a][this.threadID]=this.contextValueStack[a]};b.read=function(a){if(this.exhausted)return null;var b=X;X=this;var c=Sa.current;Sa.current=Ka;try{for(var h=[\"\"],t=!1;h[0].length<a;){if(0===this.stack.length){this.exhausted=!0;var g=this.threadID;\nJ[g]=J[0];J[0]=g;break}var e=this.stack[this.stack.length-1];if(t||e.childIndex>=e.children.length){var L=e.footer;\"\"!==L&&(this.previousWasTextNode=!1);this.stack.pop();if(\"select\"===e.type)this.currentSelectValue=null;else if(null!=e.type&&null!=e.type.type&&e.type.type.$$typeof===B)this.popProvider(e.type);else if(e.type===D){this.suspenseDepth--;var G=h.pop();if(t){t=!1;var C=e.fallbackFrame;if(!C)throw Error(p(303));this.stack.push(C);h[this.suspenseDepth]+=\"\\x3c!--$!--\\x3e\";continue}else h[this.suspenseDepth]+=\nG}h[this.suspenseDepth]+=L}else{var n=e.children[e.childIndex++],k=\"\";try{k+=this.render(n,e.context,e.domNamespace)}catch(v){if(null!=v&&\"function\"===typeof v.then)throw Error(p(294));throw v;}finally{}h.length<=this.suspenseDepth&&h.push(\"\");h[this.suspenseDepth]+=k}}return h[0]}finally{Sa.current=c,X=b,Ea()}};b.render=function(a,b,f){if(\"string\"===typeof a||\"number\"===typeof a){f=\"\"+a;if(\"\"===f)return\"\";if(this.makeStaticMarkup)return O(f);if(this.previousWasTextNode)return\"\\x3c!-- --\\x3e\"+O(f);\nthis.previousWasTextNode=!0;return O(f)}b=ab(a,b,this.threadID);a=b.child;b=b.context;if(null===a||!1===a)return\"\";if(!m.isValidElement(a)){if(null!=a&&null!=a.$$typeof){f=a.$$typeof;if(f===q)throw Error(p(257));throw Error(p(258,f.toString()));}a=Z(a);this.stack.push({type:null,domNamespace:f,children:a,childIndex:0,context:b,footer:\"\"});return\"\"}var c=a.type;if(\"string\"===typeof c)return this.renderDOM(a,b,f);switch(c){case ka:case ja:case u:case z:case ca:case r:return a=Z(a.props.children),this.stack.push({type:null,\ndomNamespace:f,children:a,childIndex:0,context:b,footer:\"\"}),\"\";case D:throw Error(p(294));case ia:throw Error(p(343));}if(\"object\"===typeof c&&null!==c)switch(c.$$typeof){case ba:P={};var d=c.render(a.props,a.ref);d=Da(c.render,a.props,d,a.ref);d=Z(d);this.stack.push({type:null,domNamespace:f,children:d,childIndex:0,context:b,footer:\"\"});return\"\";case da:return a=[m.createElement(c.type,l({ref:a.ref},a.props))],this.stack.push({type:null,domNamespace:f,children:a,childIndex:0,context:b,footer:\"\"}),\n\"\";case B:return c=Z(a.props.children),f={type:a,domNamespace:f,children:c,childIndex:0,context:b,footer:\"\"},this.pushProvider(a),this.stack.push(f),\"\";case aa:c=a.type;d=a.props;var g=this.threadID;I(c,g);c=Z(d.children(c[g]));this.stack.push({type:a,domNamespace:f,children:c,childIndex:0,context:b,footer:\"\"});return\"\";case ha:throw Error(p(338));case ea:return c=a.type,d=c._init,c=d(c._payload),a=[m.createElement(c,l({ref:a.ref},a.props))],this.stack.push({type:null,domNamespace:f,children:a,childIndex:0,\ncontext:b,footer:\"\"}),\"\"}throw Error(p(130,null==c?c:typeof c,\"\"));};b.renderDOM=function(a,b,f){var c=a.type.toLowerCase();f===La.html&&Ma(c);if(!Va.hasOwnProperty(c)){if(!Ua.test(c))throw Error(p(65,c));Va[c]=!0}var d=a.props;if(\"input\"===c)d=l({type:void 0},d,{defaultChecked:void 0,defaultValue:void 0,value:null!=d.value?d.value:d.defaultValue,checked:null!=d.checked?d.checked:d.defaultChecked});else if(\"textarea\"===c){var g=d.value;if(null==g){g=d.defaultValue;var e=d.children;if(null!=e){if(null!=\ng)throw Error(p(92));if(Array.isArray(e)){if(!(1>=e.length))throw Error(p(93));e=e[0]}g=\"\"+e}null==g&&(g=\"\")}d=l({},d,{value:void 0,children:\"\"+g})}else if(\"select\"===c)this.currentSelectValue=null!=d.value?d.value:d.defaultValue,d=l({},d,{value:void 0});else if(\"option\"===c){e=this.currentSelectValue;var L=Xa(d.children);if(null!=e){var G=null!=d.value?d.value+\"\":L;g=!1;if(Array.isArray(e))for(var C=0;C<e.length;C++){if(\"\"+e[C]===G){g=!0;break}}else g=\"\"+e===G;d=l({selected:void 0,children:void 0},\nd,{selected:g,children:L})}}if(g=d){if(Oa[c]&&(null!=g.children||null!=g.dangerouslySetInnerHTML))throw Error(p(137,c));if(null!=g.dangerouslySetInnerHTML){if(null!=g.children)throw Error(p(60));if(!(\"object\"===typeof g.dangerouslySetInnerHTML&&\"__html\"in g.dangerouslySetInnerHTML))throw Error(p(61));}if(null!=g.style&&\"object\"!==typeof g.style)throw Error(p(62));}g=d;e=this.makeStaticMarkup;L=1===this.stack.length;G=\"<\"+a.type;b:if(-1===c.indexOf(\"-\"))C=\"string\"===typeof g.is;else switch(c){case \"annotation-xml\":case \"color-profile\":case \"font-face\":case \"font-face-src\":case \"font-face-uri\":case \"font-face-format\":case \"font-face-name\":case \"missing-glyph\":C=\n!1;break b;default:C=!0}for(w in g)if(Ya.call(g,w)){var n=g[w];if(null!=n){if(\"style\"===w){var k=void 0,v=\"\",H=\"\";for(k in n)if(n.hasOwnProperty(k)){var x=0===k.indexOf(\"--\"),y=n[k];if(null!=y){if(x)var A=k;else if(A=k,Wa.hasOwnProperty(A))A=Wa[A];else{var cb=A.replace(Qa,\"-$1\").toLowerCase().replace(Ra,\"-ms-\");A=Wa[A]=cb}v+=H+A+\":\";H=k;x=null==y||\"boolean\"===typeof y||\"\"===y?\"\":x||\"number\"!==typeof y||0===y||Y.hasOwnProperty(H)&&Y[H]?(\"\"+y).trim():y+\"px\";v+=x;H=\";\"}}n=v||null}k=null;C?Za.hasOwnProperty(w)||\n(k=w,k=sa(k)&&null!=n?k+'=\"'+(O(n)+'\"'):\"\"):k=ya(w,n);k&&(G+=\" \"+k)}}e||L&&(G+=' data-reactroot=\"\"');var w=G;g=\"\";Na.hasOwnProperty(c)?w+=\"/>\":(w+=\">\",g=\"</\"+a.type+\">\");a:{e=d.dangerouslySetInnerHTML;if(null!=e){if(null!=e.__html){e=e.__html;break a}}else if(e=d.children,\"string\"===typeof e||\"number\"===typeof e){e=O(e);break a}e=null}null!=e?(d=[],Ta.hasOwnProperty(c)&&\"\\n\"===e.charAt(0)&&(w+=\"\\n\"),w+=e):d=Z(d.children);a=a.type;f=null==f||\"http://www.w3.org/1999/xhtml\"===f?Ma(a):\"http://www.w3.org/2000/svg\"===\nf&&\"foreignObject\"===a?\"http://www.w3.org/1999/xhtml\":f;this.stack.push({domNamespace:f,type:c,children:d,childIndex:0,context:b,footer:g});this.previousWasTextNode=!1;return w};return a}();exports.renderToNodeStream=function(){throw Error(p(207));};exports.renderToStaticMarkup=function(a,b){a=new bb(a,!0,b);try{return a.read(Infinity)}finally{a.destroy()}};exports.renderToStaticNodeStream=function(){throw Error(p(208));};exports.renderToString=function(a,b){a=new bb(a,!1,b);try{return a.read(Infinity)}finally{a.destroy()}};\nexports.version=\"17.0.2\";\n","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('./cjs/react-dom-server.browser.production.min.js');\n} else {\n  module.exports = require('./cjs/react-dom-server.browser.development.js');\n}\n","'use strict';\n\nmodule.exports = (string, separator) => {\n\tif (!(typeof string === 'string' && typeof separator === 'string')) {\n\t\tthrow new TypeError('Expected the arguments to be of type `string`');\n\t}\n\n\tif (separator === '') {\n\t\treturn [string];\n\t}\n\n\tconst separatorIndex = string.indexOf(separator);\n\n\tif (separatorIndex === -1) {\n\t\treturn [string];\n\t}\n\n\treturn [\n\t\tstring.slice(0, separatorIndex),\n\t\tstring.slice(separatorIndex + separator.length)\n\t];\n};\n","'use strict';\nmodule.exports = str => encodeURIComponent(str).replace(/[!'()*]/g, x => `%${x.charCodeAt(0).toString(16).toUpperCase()}`);\n","\nmodule.exports = function () {\n  var selection = document.getSelection();\n  if (!selection.rangeCount) {\n    return function () {};\n  }\n  var active = document.activeElement;\n\n  var ranges = [];\n  for (var i = 0; i < selection.rangeCount; i++) {\n    ranges.push(selection.getRangeAt(i));\n  }\n\n  switch (active.tagName.toUpperCase()) { // .toUpperCase handles XHTML\n    case 'INPUT':\n    case 'TEXTAREA':\n      active.blur();\n      break;\n\n    default:\n      active = null;\n      break;\n  }\n\n  selection.removeAllRanges();\n  return function () {\n    selection.type === 'Caret' &&\n    selection.removeAllRanges();\n\n    if (!selection.rangeCount) {\n      ranges.forEach(function(range) {\n        selection.addRange(range);\n      });\n    }\n\n    active &&\n    active.focus();\n  };\n};\n","'use strict';\nvar tryToString = require('../internals/try-to-string');\n\nvar $TypeError = TypeError;\n\nmodule.exports = function (O, P) {\n  if (!delete O[P]) throw new $TypeError('Cannot delete property ' + tryToString(P) + ' of ' + tryToString(O));\n};\n","'use strict';\nvar IS_DENO = require('../internals/engine-is-deno');\nvar IS_NODE = require('../internals/engine-is-node');\n\nmodule.exports = !IS_DENO && !IS_NODE\n  && typeof window == 'object'\n  && typeof document == 'object';\n","'use strict';\n/* global Deno -- Deno case */\nmodule.exports = typeof Deno == 'object' && Deno && typeof Deno.version == 'object';\n","'use strict';\nvar bind = require('../internals/function-bind-context');\nvar call = require('../internals/function-call');\nvar anObject = require('../internals/an-object');\nvar tryToString = require('../internals/try-to-string');\nvar isArrayIteratorMethod = require('../internals/is-array-iterator-method');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar isPrototypeOf = require('../internals/object-is-prototype-of');\nvar getIterator = require('../internals/get-iterator');\nvar getIteratorMethod = require('../internals/get-iterator-method');\nvar iteratorClose = require('../internals/iterator-close');\n\nvar $TypeError = TypeError;\n\nvar Result = function (stopped, result) {\n  this.stopped = stopped;\n  this.result = result;\n};\n\nvar ResultPrototype = Result.prototype;\n\nmodule.exports = function (iterable, unboundFunction, options) {\n  var that = options && options.that;\n  var AS_ENTRIES = !!(options && options.AS_ENTRIES);\n  var IS_RECORD = !!(options && options.IS_RECORD);\n  var IS_ITERATOR = !!(options && options.IS_ITERATOR);\n  var INTERRUPTED = !!(options && options.INTERRUPTED);\n  var fn = bind(unboundFunction, that);\n  var iterator, iterFn, index, length, result, next, step;\n\n  var stop = function (condition) {\n    if (iterator) iteratorClose(iterator, 'normal', condition);\n    return new Result(true, condition);\n  };\n\n  var callFn = function (value) {\n    if (AS_ENTRIES) {\n      anObject(value);\n      return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]);\n    } return INTERRUPTED ? fn(value, stop) : fn(value);\n  };\n\n  if (IS_RECORD) {\n    iterator = iterable.iterator;\n  } else if (IS_ITERATOR) {\n    iterator = iterable;\n  } else {\n    iterFn = getIteratorMethod(iterable);\n    if (!iterFn) throw new $TypeError(tryToString(iterable) + ' is not iterable');\n    // optimisation for array iterators\n    if (isArrayIteratorMethod(iterFn)) {\n      for (index = 0, length = lengthOfArrayLike(iterable); length > index; index++) {\n        result = callFn(iterable[index]);\n        if (result && isPrototypeOf(ResultPrototype, result)) return result;\n      } return new Result(false);\n    }\n    iterator = getIterator(iterable, iterFn);\n  }\n\n  next = IS_RECORD ? iterable.next : iterator.next;\n  while (!(step = call(next, iterator)).done) {\n    try {\n      result = callFn(step.value);\n    } catch (error) {\n      iteratorClose(iterator, 'throw', error);\n    }\n    if (typeof result == 'object' && result && isPrototypeOf(ResultPrototype, result)) return result;\n  } return new Result(false);\n};\n","'use strict';\nmodule.exports = function (exec) {\n  try {\n    return { error: false, value: exec() };\n  } catch (error) {\n    return { error: true, value: error };\n  }\n};\n","'use strict';\nvar global = require('../internals/global');\nvar NativePromiseConstructor = require('../internals/promise-native-constructor');\nvar isCallable = require('../internals/is-callable');\nvar isForced = require('../internals/is-forced');\nvar inspectSource = require('../internals/inspect-source');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar IS_BROWSER = require('../internals/engine-is-browser');\nvar IS_DENO = require('../internals/engine-is-deno');\nvar IS_PURE = require('../internals/is-pure');\nvar V8_VERSION = require('../internals/engine-v8-version');\n\nvar NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype;\nvar SPECIES = wellKnownSymbol('species');\nvar SUBCLASSING = false;\nvar NATIVE_PROMISE_REJECTION_EVENT = isCallable(global.PromiseRejectionEvent);\n\nvar FORCED_PROMISE_CONSTRUCTOR = isForced('Promise', function () {\n  var PROMISE_CONSTRUCTOR_SOURCE = inspectSource(NativePromiseConstructor);\n  var GLOBAL_CORE_JS_PROMISE = PROMISE_CONSTRUCTOR_SOURCE !== String(NativePromiseConstructor);\n  // V8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables\n  // https://bugs.chromium.org/p/chromium/issues/detail?id=830565\n  // We can't detect it synchronously, so just check versions\n  if (!GLOBAL_CORE_JS_PROMISE && V8_VERSION === 66) return true;\n  // We need Promise#{ catch, finally } in the pure version for preventing prototype pollution\n  if (IS_PURE && !(NativePromisePrototype['catch'] && NativePromisePrototype['finally'])) return true;\n  // We can't use @@species feature detection in V8 since it causes\n  // deoptimization and performance degradation\n  // https://github.com/zloirock/core-js/issues/679\n  if (!V8_VERSION || V8_VERSION < 51 || !/native code/.test(PROMISE_CONSTRUCTOR_SOURCE)) {\n    // Detect correctness of subclassing with @@species support\n    var promise = new NativePromiseConstructor(function (resolve) { resolve(1); });\n    var FakePromise = function (exec) {\n      exec(function () { /* empty */ }, function () { /* empty */ });\n    };\n    var constructor = promise.constructor = {};\n    constructor[SPECIES] = FakePromise;\n    SUBCLASSING = promise.then(function () { /* empty */ }) instanceof FakePromise;\n    if (!SUBCLASSING) return true;\n  // Unhandled rejections tracking support, NodeJS Promise without it fails @@species test\n  } return !GLOBAL_CORE_JS_PROMISE && (IS_BROWSER || IS_DENO) && !NATIVE_PROMISE_REJECTION_EVENT;\n});\n\nmodule.exports = {\n  CONSTRUCTOR: FORCED_PROMISE_CONSTRUCTOR,\n  REJECTION_EVENT: NATIVE_PROMISE_REJECTION_EVENT,\n  SUBCLASSING: SUBCLASSING\n};\n","'use strict';\nvar NativePromiseConstructor = require('../internals/promise-native-constructor');\nvar checkCorrectnessOfIteration = require('../internals/check-correctness-of-iteration');\nvar FORCED_PROMISE_CONSTRUCTOR = require('../internals/promise-constructor-detection').CONSTRUCTOR;\n\nmodule.exports = FORCED_PROMISE_CONSTRUCTOR || !checkCorrectnessOfIteration(function (iterable) {\n  NativePromiseConstructor.all(iterable).then(undefined, function () { /* empty */ });\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar toObject = require('../internals/to-object');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar setArrayLength = require('../internals/array-set-length');\nvar deletePropertyOrThrow = require('../internals/delete-property-or-throw');\nvar doesNotExceedSafeInteger = require('../internals/does-not-exceed-safe-integer');\n\n// IE8-\nvar INCORRECT_RESULT = [].unshift(0) !== 1;\n\n// V8 ~ Chrome < 71 and Safari <= 15.4, FF < 23 throws InternalError\nvar properErrorOnNonWritableLength = function () {\n  try {\n    // eslint-disable-next-line es/no-object-defineproperty -- safe\n    Object.defineProperty([], 'length', { writable: false }).unshift();\n  } catch (error) {\n    return error instanceof TypeError;\n  }\n};\n\nvar FORCED = INCORRECT_RESULT || !properErrorOnNonWritableLength();\n\n// `Array.prototype.unshift` method\n// https://tc39.es/ecma262/#sec-array.prototype.unshift\n$({ target: 'Array', proto: true, arity: 1, forced: FORCED }, {\n  // eslint-disable-next-line no-unused-vars -- required for `.length`\n  unshift: function unshift(item) {\n    var O = toObject(this);\n    var len = lengthOfArrayLike(O);\n    var argCount = arguments.length;\n    if (argCount) {\n      doesNotExceedSafeInteger(len + argCount);\n      var k = len;\n      while (k--) {\n        var to = k + argCount;\n        if (k in O) O[to] = O[k];\n        else deletePropertyOrThrow(O, to);\n      }\n      for (var j = 0; j < argCount; j++) {\n        O[j] = arguments[j];\n      }\n    } return setArrayLength(O, len + argCount);\n  }\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar call = require('../internals/function-call');\nvar aCallable = require('../internals/a-callable');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\nvar perform = require('../internals/perform');\nvar iterate = require('../internals/iterate');\nvar PROMISE_STATICS_INCORRECT_ITERATION = require('../internals/promise-statics-incorrect-iteration');\n\n// `Promise.allSettled` method\n// https://tc39.es/ecma262/#sec-promise.allsettled\n$({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION }, {\n  allSettled: function allSettled(iterable) {\n    var C = this;\n    var capability = newPromiseCapabilityModule.f(C);\n    var resolve = capability.resolve;\n    var reject = capability.reject;\n    var result = perform(function () {\n      var promiseResolve = aCallable(C.resolve);\n      var values = [];\n      var counter = 0;\n      var remaining = 1;\n      iterate(iterable, function (promise) {\n        var index = counter++;\n        var alreadyCalled = false;\n        remaining++;\n        call(promiseResolve, C, promise).then(function (value) {\n          if (alreadyCalled) return;\n          alreadyCalled = true;\n          values[index] = { status: 'fulfilled', value: value };\n          --remaining || resolve(values);\n        }, function (error) {\n          if (alreadyCalled) return;\n          alreadyCalled = true;\n          values[index] = { status: 'rejected', reason: error };\n          --remaining || resolve(values);\n        });\n      });\n      --remaining || resolve(values);\n    });\n    if (result.error) reject(result.value);\n    return capability.promise;\n  }\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar call = require('../internals/function-call');\n\n// `URL.prototype.toJSON` method\n// https://url.spec.whatwg.org/#dom-url-tojson\n$({ target: 'URL', proto: true, enumerable: true }, {\n  toJSON: function toJSON() {\n    return call(URL.prototype.toString, this);\n  }\n});\n","\"use client\";\nimport {\n  useMenuScopedContext\n} from \"./IG6NVGLB.js\";\nimport {\n  useMenubarScopedContext\n} from \"./VBF5EZBB.js\";\nimport {\n  useCompositeHover\n} from \"./WL6TTPTB.js\";\nimport {\n  useCompositeItem\n} from \"./C6OBNQ4F.js\";\nimport {\n  createElement,\n  createHook,\n  forwardRef,\n  memo\n} from \"./5M6RSQEC.js\";\nimport {\n  useStoreState\n} from \"./EKQEJRUF.js\";\nimport {\n  useBooleanEvent,\n  useEvent\n} from \"./6O5OEQGF.js\";\nimport {\n  __objRest,\n  __spreadProps,\n  __spreadValues\n} from \"./4R3V3JGP.js\";\n\n// src/menu/menu-item.ts\nimport { getDocument, getPopupItemRole } from \"@ariakit/core/utils/dom\";\nimport { isDownloading, isOpeningInNewTab } from \"@ariakit/core/utils/events\";\nimport { hasFocusWithin } from \"@ariakit/core/utils/focus\";\nimport { invariant } from \"@ariakit/core/utils/misc\";\nvar TagName = \"div\";\nfunction menuHasFocus(baseElement, items, currentTarget) {\n  var _a;\n  if (!baseElement)\n    return false;\n  if (hasFocusWithin(baseElement))\n    return true;\n  const expandedItem = items == null ? void 0 : items.find((item) => {\n    var _a2;\n    if (item.element === currentTarget)\n      return false;\n    return ((_a2 = item.element) == null ? void 0 : _a2.getAttribute(\"aria-expanded\")) === \"true\";\n  });\n  const expandedMenuId = (_a = expandedItem == null ? void 0 : expandedItem.element) == null ? void 0 : _a.getAttribute(\"aria-controls\");\n  if (!expandedMenuId)\n    return false;\n  const doc = getDocument(baseElement);\n  const expandedMenu = doc.getElementById(expandedMenuId);\n  if (!expandedMenu)\n    return false;\n  if (hasFocusWithin(expandedMenu))\n    return true;\n  return !!expandedMenu.querySelector(\"[role=menuitem][aria-expanded=true]\");\n}\nvar useMenuItem = createHook(\n  function useMenuItem2(_a) {\n    var _b = _a, {\n      store,\n      hideOnClick = true,\n      preventScrollOnKeyDown = true,\n      focusOnHover,\n      blurOnHoverEnd\n    } = _b, props = __objRest(_b, [\n      \"store\",\n      \"hideOnClick\",\n      \"preventScrollOnKeyDown\",\n      \"focusOnHover\",\n      \"blurOnHoverEnd\"\n    ]);\n    const menuContext = useMenuScopedContext(true);\n    const menubarContext = useMenubarScopedContext();\n    store = store || menuContext || menubarContext;\n    invariant(\n      store,\n      process.env.NODE_ENV !== \"production\" && \"MenuItem must be wrapped in a MenuList, Menu or Menubar component\"\n    );\n    const onClickProp = props.onClick;\n    const hideOnClickProp = useBooleanEvent(hideOnClick);\n    const hideMenu = \"hideAll\" in store ? store.hideAll : void 0;\n    const isWithinMenu = !!hideMenu;\n    const onClick = useEvent((event) => {\n      onClickProp == null ? void 0 : onClickProp(event);\n      if (event.defaultPrevented)\n        return;\n      if (isDownloading(event))\n        return;\n      if (isOpeningInNewTab(event))\n        return;\n      if (!hideMenu)\n        return;\n      const popupType = event.currentTarget.getAttribute(\"aria-haspopup\");\n      if (popupType === \"menu\")\n        return;\n      if (!hideOnClickProp(event))\n        return;\n      hideMenu();\n    });\n    const contentElement = useStoreState(\n      store,\n      (state) => \"contentElement\" in state ? state.contentElement : null\n    );\n    const role = getPopupItemRole(contentElement, \"menuitem\");\n    props = __spreadProps(__spreadValues({\n      role\n    }, props), {\n      onClick\n    });\n    props = useCompositeItem(__spreadValues({\n      store,\n      preventScrollOnKeyDown\n    }, props));\n    props = useCompositeHover(__spreadProps(__spreadValues({\n      store\n    }, props), {\n      focusOnHover(event) {\n        const getFocusOnHover = () => {\n          if (typeof focusOnHover === \"function\")\n            return focusOnHover(event);\n          if (focusOnHover != null)\n            return focusOnHover;\n          return true;\n        };\n        if (!store)\n          return false;\n        if (!getFocusOnHover())\n          return false;\n        const { baseElement, items } = store.getState();\n        if (isWithinMenu) {\n          if (event.currentTarget.hasAttribute(\"aria-expanded\")) {\n            event.currentTarget.focus();\n          }\n          return true;\n        }\n        if (menuHasFocus(baseElement, items, event.currentTarget)) {\n          event.currentTarget.focus();\n          return true;\n        }\n        return false;\n      },\n      blurOnHoverEnd(event) {\n        if (typeof blurOnHoverEnd === \"function\")\n          return blurOnHoverEnd(event);\n        if (blurOnHoverEnd != null)\n          return blurOnHoverEnd;\n        return isWithinMenu;\n      }\n    }));\n    return props;\n  }\n);\nvar MenuItem = memo(\n  forwardRef(function MenuItem2(props) {\n    const htmlProps = useMenuItem(props);\n    return createElement(TagName, htmlProps);\n  })\n);\n\nexport {\n  useMenuItem,\n  MenuItem\n};\n","\"use client\";\nimport {\n  CompositeContextProvider,\n  CompositeScopedContextProvider\n} from \"./3D6OCOHF.js\";\nimport {\n  createStoreContext\n} from \"./5M6RSQEC.js\";\n\n// src/tab/tab-context.tsx\nvar ctx = createStoreContext(\n  [CompositeContextProvider],\n  [CompositeScopedContextProvider]\n);\nvar useTabContext = ctx.useContext;\nvar useTabScopedContext = ctx.useScopedContext;\nvar useTabProviderContext = ctx.useProviderContext;\nvar TabContextProvider = ctx.ContextProvider;\nvar TabScopedContextProvider = ctx.ScopedContextProvider;\n\nexport {\n  useTabContext,\n  useTabScopedContext,\n  useTabProviderContext,\n  TabContextProvider,\n  TabScopedContextProvider\n};\n","\"use client\";\nimport {\n  MenubarContextProvider,\n  MenubarScopedContextProvider,\n  useMenubarContext,\n  useMenubarProviderContext,\n  useMenubarScopedContext\n} from \"./VBF5EZBB.js\";\nimport {\n  CompositeContextProvider,\n  CompositeScopedContextProvider\n} from \"./3D6OCOHF.js\";\nimport {\n  HovercardContextProvider,\n  HovercardScopedContextProvider\n} from \"./TWDHCE7Y.js\";\nimport {\n  createStoreContext\n} from \"./5M6RSQEC.js\";\n\n// src/menu/menu-context.ts\nimport { createContext } from \"react\";\nvar menu = createStoreContext(\n  [CompositeContextProvider, HovercardContextProvider],\n  [CompositeScopedContextProvider, HovercardScopedContextProvider]\n);\nvar useMenuContext = menu.useContext;\nvar useMenuScopedContext = menu.useScopedContext;\nvar useMenuProviderContext = menu.useProviderContext;\nvar MenuContextProvider = menu.ContextProvider;\nvar MenuScopedContextProvider = menu.ScopedContextProvider;\nvar useMenuBarContext = useMenubarContext;\nvar useMenuBarScopedContext = useMenubarScopedContext;\nvar useMenuBarProviderContext = useMenubarProviderContext;\nvar MenuBarContextProvider = MenubarContextProvider;\nvar MenuBarScopedContextProvider = MenubarScopedContextProvider;\nvar MenuItemCheckedContext = createContext(\n  void 0\n);\n\nexport {\n  useMenuContext,\n  useMenuScopedContext,\n  useMenuProviderContext,\n  MenuContextProvider,\n  MenuScopedContextProvider,\n  useMenuBarContext,\n  useMenuBarScopedContext,\n  useMenuBarProviderContext,\n  MenuBarContextProvider,\n  MenuBarScopedContextProvider,\n  MenuItemCheckedContext\n};\n","\"use client\";\nimport {\n  createHovercardStore\n} from \"../__chunks/BRS7GKWU.js\";\nimport \"../__chunks/MFZZDIHG.js\";\nimport \"../__chunks/5RJNXXU2.js\";\nimport \"../__chunks/WCKXDMU7.js\";\nimport {\n  createCompositeStore\n} from \"../__chunks/2H5K47H4.js\";\nimport \"../__chunks/URUD7X4C.js\";\nimport {\n  createStore,\n  mergeStore,\n  omit,\n  pick,\n  setup,\n  sync,\n  throwOnConflictingProps\n} from \"../__chunks/R676XYVY.js\";\nimport {\n  applyState,\n  defaultValue\n} from \"../__chunks/22HHDS5F.js\";\nimport \"../__chunks/RRSZHCH6.js\";\nimport \"../__chunks/7PRQYBBV.js\";\nimport {\n  __objRest,\n  __spreadProps,\n  __spreadValues\n} from \"../__chunks/4R3V3JGP.js\";\n\n// src/menu/menu-store.ts\nfunction createMenuStore(_a = {}) {\n  var _b = _a, {\n    combobox,\n    parent,\n    menubar\n  } = _b, props = __objRest(_b, [\n    \"combobox\",\n    \"parent\",\n    \"menubar\"\n  ]);\n  const parentIsMenubar = !!menubar && !parent;\n  const store = mergeStore(\n    props.store,\n    pick(parent, [\"values\"]),\n    omit(combobox, [\n      \"arrowElement\",\n      \"anchorElement\",\n      \"contentElement\",\n      \"popoverElement\",\n      \"disclosureElement\"\n    ])\n  );\n  throwOnConflictingProps(props, store);\n  const syncState = store.getState();\n  const composite = createCompositeStore(__spreadProps(__spreadValues({}, props), {\n    store,\n    orientation: defaultValue(\n      props.orientation,\n      syncState.orientation,\n      \"vertical\"\n    )\n  }));\n  const hovercard = createHovercardStore(__spreadProps(__spreadValues({}, props), {\n    store,\n    placement: defaultValue(\n      props.placement,\n      syncState.placement,\n      \"bottom-start\"\n    ),\n    timeout: defaultValue(\n      props.timeout,\n      syncState.timeout,\n      parentIsMenubar ? 0 : 150\n    ),\n    hideTimeout: defaultValue(props.hideTimeout, syncState.hideTimeout, 0)\n  }));\n  const initialState = __spreadProps(__spreadValues(__spreadValues({}, composite.getState()), hovercard.getState()), {\n    initialFocus: defaultValue(syncState.initialFocus, \"container\"),\n    values: defaultValue(\n      props.values,\n      syncState.values,\n      props.defaultValues,\n      {}\n    )\n  });\n  const menu = createStore(initialState, composite, hovercard, store);\n  setup(\n    menu,\n    () => sync(menu, [\"mounted\"], (state) => {\n      if (state.mounted)\n        return;\n      menu.setState(\"activeId\", null);\n    })\n  );\n  setup(\n    menu,\n    () => sync(parent, [\"orientation\"], (state) => {\n      menu.setState(\n        \"placement\",\n        state.orientation === \"vertical\" ? \"right-start\" : \"bottom-start\"\n      );\n    })\n  );\n  return __spreadProps(__spreadValues(__spreadValues(__spreadValues({}, composite), hovercard), menu), {\n    combobox,\n    parent,\n    menubar,\n    hideAll: () => {\n      hovercard.hide();\n      parent == null ? void 0 : parent.hideAll();\n    },\n    setInitialFocus: (value) => menu.setState(\"initialFocus\", value),\n    setValues: (values) => menu.setState(\"values\", values),\n    setValue: (name, value) => {\n      if (name === \"__proto__\")\n        return;\n      if (name === \"constructor\")\n        return;\n      if (Array.isArray(name))\n        return;\n      menu.setState(\"values\", (values) => {\n        const prevValue = values[name];\n        const nextValue = applyState(value, prevValue);\n        if (nextValue === prevValue)\n          return values;\n        return __spreadProps(__spreadValues({}, values), {\n          [name]: nextValue !== void 0 && nextValue\n        });\n      });\n    }\n  });\n}\nexport {\n  createMenuStore\n};\n","\"use client\";\nimport {\n  useMenuContext\n} from \"./IG6NVGLB.js\";\nimport {\n  useMenubarContext\n} from \"./VBF5EZBB.js\";\nimport {\n  useComboboxProviderContext\n} from \"./UNDSQXBK.js\";\nimport {\n  useCompositeStoreProps\n} from \"./7GBW5FLS.js\";\nimport {\n  useHovercardStoreProps\n} from \"./E5E7G32I.js\";\nimport {\n  useStore,\n  useStoreProps\n} from \"./EKQEJRUF.js\";\nimport {\n  useUpdateEffect\n} from \"./6O5OEQGF.js\";\nimport {\n  __spreadProps,\n  __spreadValues\n} from \"./4R3V3JGP.js\";\n\n// src/menu/menu-store.ts\nimport * as Core from \"@ariakit/core/menu/menu-store\";\nfunction useMenuStoreProps(store, update, props) {\n  useUpdateEffect(update, [props.combobox, props.parent, props.menubar]);\n  useStoreProps(store, props, \"values\", \"setValues\");\n  return Object.assign(\n    useHovercardStoreProps(\n      useCompositeStoreProps(store, update, props),\n      update,\n      props\n    ),\n    {\n      combobox: props.combobox,\n      parent: props.parent,\n      menubar: props.menubar\n    }\n  );\n}\nfunction useMenuStore(props = {}) {\n  const parent = useMenuContext();\n  const menubar = useMenubarContext();\n  const combobox = useComboboxProviderContext();\n  props = __spreadProps(__spreadValues({}, props), {\n    parent: props.parent !== void 0 ? props.parent : parent,\n    menubar: props.menubar !== void 0 ? props.menubar : menubar,\n    combobox: props.combobox !== void 0 ? props.combobox : combobox\n  });\n  const [store, update] = useStore(Core.createMenuStore, props);\n  return useMenuStoreProps(store, update, props);\n}\n\nexport {\n  useMenuStoreProps,\n  useMenuStore\n};\n","\"use client\";\nimport {\n  createCompositeStore\n} from \"./2H5K47H4.js\";\nimport {\n  createStore\n} from \"./R676XYVY.js\";\nimport {\n  defaultValue\n} from \"./22HHDS5F.js\";\nimport {\n  __spreadProps,\n  __spreadValues\n} from \"./4R3V3JGP.js\";\n\n// src/menubar/menubar-store.ts\nfunction createMenubarStore(props = {}) {\n  var _a;\n  const syncState = (_a = props.store) == null ? void 0 : _a.getState();\n  const composite = createCompositeStore(__spreadProps(__spreadValues({}, props), {\n    orientation: defaultValue(\n      props.orientation,\n      syncState == null ? void 0 : syncState.orientation,\n      \"horizontal\"\n    ),\n    focusLoop: defaultValue(props.focusLoop, syncState == null ? void 0 : syncState.focusLoop, true)\n  }));\n  const initialState = __spreadValues({}, composite.getState());\n  const menubar = createStore(initialState, composite, props.store);\n  return __spreadValues(__spreadValues({}, composite), menubar);\n}\n\nexport {\n  createMenubarStore\n};\n","\"use client\";\nimport {\n  useCompositeStoreProps\n} from \"./7GBW5FLS.js\";\nimport {\n  useStore\n} from \"./EKQEJRUF.js\";\n\n// src/menubar/menubar-store.ts\nimport * as Core from \"@ariakit/core/menubar/menubar-store\";\nfunction useMenubarStoreProps(store, update, props) {\n  return useCompositeStoreProps(store, update, props);\n}\nfunction useMenubarStore(props = {}) {\n  const [store, update] = useStore(Core.createMenubarStore, props);\n  return useMenubarStoreProps(store, update, props);\n}\n\nexport {\n  useMenubarStoreProps,\n  useMenubarStore\n};\n","\"use client\";\nimport {\n  MenubarScopedContextProvider,\n  useMenubarProviderContext\n} from \"./VBF5EZBB.js\";\nimport {\n  useMenubarStore\n} from \"./HVBNG5AF.js\";\nimport {\n  useComposite\n} from \"./FTNKYK65.js\";\nimport {\n  createElement,\n  createHook,\n  forwardRef\n} from \"./5M6RSQEC.js\";\nimport {\n  useWrapElement\n} from \"./6O5OEQGF.js\";\nimport {\n  __objRest,\n  __spreadValues\n} from \"./4R3V3JGP.js\";\n\n// src/menubar/menubar.tsx\nimport { jsx } from \"react/jsx-runtime\";\nvar TagName = \"div\";\nvar useMenubar = createHook(\n  function useMenubar2(_a) {\n    var _b = _a, {\n      store: storeProp,\n      composite = true,\n      orientation: orientationProp,\n      virtualFocus,\n      focusLoop,\n      rtl\n    } = _b, props = __objRest(_b, [\n      \"store\",\n      \"composite\",\n      \"orientation\",\n      \"virtualFocus\",\n      \"focusLoop\",\n      \"rtl\"\n    ]);\n    const context = useMenubarProviderContext();\n    storeProp = storeProp || context;\n    const store = useMenubarStore({\n      store: storeProp,\n      orientation: orientationProp,\n      virtualFocus,\n      focusLoop,\n      rtl\n    });\n    const orientation = store.useState(\n      (state) => !composite || state.orientation === \"both\" ? void 0 : state.orientation\n    );\n    props = useWrapElement(\n      props,\n      (element) => /* @__PURE__ */ jsx(MenubarScopedContextProvider, { value: store, children: element }),\n      [store]\n    );\n    if (composite) {\n      props = __spreadValues({\n        role: \"menubar\",\n        \"aria-orientation\": orientation\n      }, props);\n    }\n    props = useComposite(__spreadValues({ store, composite }, props));\n    return props;\n  }\n);\nvar Menubar = forwardRef(function Menubar2(props) {\n  const htmlProps = useMenubar(props);\n  return createElement(TagName, htmlProps);\n});\n\nexport {\n  useMenubar,\n  Menubar\n};\n","\"use client\";\nimport {\n  CompositeContextProvider,\n  CompositeScopedContextProvider\n} from \"./3D6OCOHF.js\";\nimport {\n  createStoreContext\n} from \"./5M6RSQEC.js\";\n\n// src/menubar/menubar-context.ts\nimport { createContext } from \"react\";\nvar menubar = createStoreContext(\n  [CompositeContextProvider],\n  [CompositeScopedContextProvider]\n);\nvar useMenubarContext = menubar.useContext;\nvar useMenubarScopedContext = menubar.useScopedContext;\nvar useMenubarProviderContext = menubar.useProviderContext;\nvar MenubarContextProvider = menubar.ContextProvider;\nvar MenubarScopedContextProvider = menubar.ScopedContextProvider;\nvar MenuItemCheckedContext = createContext(\n  void 0\n);\n\nexport {\n  useMenubarContext,\n  useMenubarScopedContext,\n  useMenubarProviderContext,\n  MenubarContextProvider,\n  MenubarScopedContextProvider,\n  MenuItemCheckedContext\n};\n","\"use client\";\nimport {\n  MenuContextProvider,\n  useMenuProviderContext\n} from \"../__chunks/IG6NVGLB.js\";\nimport \"../__chunks/VBF5EZBB.js\";\nimport {\n  usePopoverDisclosure\n} from \"../__chunks/Z72LDQLY.js\";\nimport \"../__chunks/5SF76VVA.js\";\nimport \"../__chunks/AFNONYRE.js\";\nimport \"../__chunks/NLT7LY5Y.js\";\nimport \"../__chunks/JJ3MV4KB.js\";\nimport {\n  useCompositeTypeahead\n} from \"../__chunks/DMSZFK7W.js\";\nimport \"../__chunks/KSZPJCUA.js\";\nimport {\n  useHovercardAnchor\n} from \"../__chunks/FWINX72I.js\";\nimport \"../__chunks/3IEDWLST.js\";\nimport \"../__chunks/3D6OCOHF.js\";\nimport \"../__chunks/MADQZZRL.js\";\nimport {\n  Role\n} from \"../__chunks/CBTO7DFZ.js\";\nimport \"../__chunks/TWDHCE7Y.js\";\nimport \"../__chunks/TE637IA7.js\";\nimport \"../__chunks/XXVAHUAO.js\";\nimport \"../__chunks/J55AVALY.js\";\nimport \"../__chunks/WAZE6NXP.js\";\nimport \"../__chunks/SHA3WOPI.js\";\nimport {\n  createElement,\n  createHook,\n  forwardRef\n} from \"../__chunks/5M6RSQEC.js\";\nimport {\n  useStoreState\n} from \"../__chunks/EKQEJRUF.js\";\nimport {\n  useEvent,\n  useId,\n  useMergeRefs,\n  useWrapElement\n} from \"../__chunks/6O5OEQGF.js\";\nimport \"../__chunks/XM66DUTO.js\";\nimport {\n  __objRest,\n  __spreadProps,\n  __spreadValues\n} from \"../__chunks/4R3V3JGP.js\";\n\n// src/menu/menu-button.tsx\nimport { useRef } from \"react\";\nimport { getPopupItemRole, getPopupRole } from \"@ariakit/core/utils/dom\";\nimport { disabledFromProps, invariant } from \"@ariakit/core/utils/misc\";\nimport { jsx } from \"react/jsx-runtime\";\nvar TagName = \"button\";\nfunction getInitialFocus(event, dir) {\n  const keyMap = {\n    ArrowDown: dir === \"bottom\" || dir === \"top\" ? \"first\" : false,\n    ArrowUp: dir === \"bottom\" || dir === \"top\" ? \"last\" : false,\n    ArrowRight: dir === \"right\" ? \"first\" : false,\n    ArrowLeft: dir === \"left\" ? \"first\" : false\n  };\n  return keyMap[event.key];\n}\nfunction hasActiveItem(items, excludeElement) {\n  return !!(items == null ? void 0 : items.some((item) => {\n    if (!item.element)\n      return false;\n    if (item.element === excludeElement)\n      return false;\n    return item.element.getAttribute(\"aria-expanded\") === \"true\";\n  }));\n}\nvar useMenuButton = createHook(\n  function useMenuButton2(_a) {\n    var _b = _a, {\n      store,\n      focusable,\n      accessibleWhenDisabled,\n      showOnHover\n    } = _b, props = __objRest(_b, [\n      \"store\",\n      \"focusable\",\n      \"accessibleWhenDisabled\",\n      \"showOnHover\"\n    ]);\n    const context = useMenuProviderContext();\n    store = store || context;\n    invariant(\n      store,\n      process.env.NODE_ENV !== \"production\" && \"MenuButton must receive a `store` prop or be wrapped in a MenuProvider component.\"\n    );\n    const ref = useRef(null);\n    const parentMenu = store.parent;\n    const parentMenubar = store.menubar;\n    const hasParentMenu = !!parentMenu;\n    const parentIsMenubar = !!parentMenubar && !hasParentMenu;\n    const disabled = disabledFromProps(props);\n    const showMenu = () => {\n      const trigger = ref.current;\n      if (!trigger)\n        return;\n      store == null ? void 0 : store.setDisclosureElement(trigger);\n      store == null ? void 0 : store.setAnchorElement(trigger);\n      store == null ? void 0 : store.show();\n    };\n    const onFocusProp = props.onFocus;\n    const onFocus = useEvent((event) => {\n      onFocusProp == null ? void 0 : onFocusProp(event);\n      if (disabled)\n        return;\n      if (event.defaultPrevented)\n        return;\n      store == null ? void 0 : store.setAutoFocusOnShow(false);\n      store == null ? void 0 : store.setActiveId(null);\n      if (!parentMenubar)\n        return;\n      if (!parentIsMenubar)\n        return;\n      const { items } = parentMenubar.getState();\n      if (hasActiveItem(items, event.currentTarget)) {\n        showMenu();\n      }\n    });\n    const dir = store.useState(\n      (state) => state.placement.split(\"-\")[0]\n    );\n    const onKeyDownProp = props.onKeyDown;\n    const onKeyDown = useEvent((event) => {\n      onKeyDownProp == null ? void 0 : onKeyDownProp(event);\n      if (disabled)\n        return;\n      if (event.defaultPrevented)\n        return;\n      const initialFocus = getInitialFocus(event, dir);\n      if (initialFocus) {\n        event.preventDefault();\n        showMenu();\n        store == null ? void 0 : store.setAutoFocusOnShow(true);\n        store == null ? void 0 : store.setInitialFocus(initialFocus);\n      }\n    });\n    const onClickProp = props.onClick;\n    const onClick = useEvent((event) => {\n      onClickProp == null ? void 0 : onClickProp(event);\n      if (event.defaultPrevented)\n        return;\n      if (!store)\n        return;\n      const isKeyboardClick = !event.detail;\n      const { open } = store.getState();\n      if (!open || isKeyboardClick) {\n        if (!hasParentMenu || isKeyboardClick) {\n          store.setAutoFocusOnShow(true);\n        }\n        store.setInitialFocus(isKeyboardClick ? \"first\" : \"container\");\n      }\n      if (hasParentMenu) {\n        showMenu();\n      }\n    });\n    props = useWrapElement(\n      props,\n      (element) => /* @__PURE__ */ jsx(MenuContextProvider, { value: store, children: element }),\n      [store]\n    );\n    if (hasParentMenu) {\n      props = __spreadProps(__spreadValues({}, props), {\n        render: /* @__PURE__ */ jsx(Role.div, { render: props.render })\n      });\n    }\n    const id = useId(props.id);\n    const parentContentElement = useStoreState(\n      (parentMenu == null ? void 0 : parentMenu.combobox) || parentMenu,\n      \"contentElement\"\n    );\n    const role = hasParentMenu || parentIsMenubar ? getPopupItemRole(parentContentElement, \"menuitem\") : void 0;\n    const contentElement = store.useState(\"contentElement\");\n    props = __spreadProps(__spreadValues({\n      id,\n      role,\n      \"aria-haspopup\": getPopupRole(contentElement, \"menu\")\n    }, props), {\n      ref: useMergeRefs(ref, props.ref),\n      onFocus,\n      onKeyDown,\n      onClick\n    });\n    props = useHovercardAnchor(__spreadProps(__spreadValues({\n      store,\n      focusable,\n      accessibleWhenDisabled\n    }, props), {\n      showOnHover: (event) => {\n        const getShowOnHover = () => {\n          if (typeof showOnHover === \"function\")\n            return showOnHover(event);\n          if (showOnHover != null)\n            return showOnHover;\n          if (hasParentMenu)\n            return true;\n          if (!parentMenubar)\n            return false;\n          const { items } = parentMenubar.getState();\n          return parentIsMenubar && hasActiveItem(items);\n        };\n        const canShowOnHover = getShowOnHover();\n        if (!canShowOnHover)\n          return false;\n        const parent = parentIsMenubar ? parentMenubar : parentMenu;\n        if (!parent)\n          return true;\n        parent.setActiveId(event.currentTarget.id);\n        return true;\n      }\n    }));\n    props = usePopoverDisclosure(__spreadValues({\n      store,\n      toggleOnClick: !hasParentMenu,\n      focusable,\n      accessibleWhenDisabled\n    }, props));\n    props = useCompositeTypeahead(__spreadValues({\n      store,\n      typeahead: parentIsMenubar\n    }, props));\n    return props;\n  }\n);\nvar MenuButton = forwardRef(function MenuButton2(props) {\n  const htmlProps = useMenuButton(props);\n  return createElement(TagName, htmlProps);\n});\nexport {\n  MenuButton,\n  useMenuButton\n};\n","\"use client\";\nimport {\n  useMenuStore\n} from \"../__chunks/MAMNGFY7.js\";\nimport {\n  MenuContextProvider\n} from \"../__chunks/IG6NVGLB.js\";\nimport \"../__chunks/VBF5EZBB.js\";\nimport \"../__chunks/UNDSQXBK.js\";\nimport \"../__chunks/7GBW5FLS.js\";\nimport \"../__chunks/Y6GYTNQ2.js\";\nimport \"../__chunks/3D6OCOHF.js\";\nimport \"../__chunks/MADQZZRL.js\";\nimport \"../__chunks/TWDHCE7Y.js\";\nimport \"../__chunks/TE637IA7.js\";\nimport \"../__chunks/XXVAHUAO.js\";\nimport \"../__chunks/J55AVALY.js\";\nimport \"../__chunks/5M6RSQEC.js\";\nimport \"../__chunks/E5E7G32I.js\";\nimport \"../__chunks/XWCFCD3Q.js\";\nimport \"../__chunks/I62TROYO.js\";\nimport \"../__chunks/HZJ2XALY.js\";\nimport \"../__chunks/EKQEJRUF.js\";\nimport \"../__chunks/6O5OEQGF.js\";\nimport \"../__chunks/XM66DUTO.js\";\nimport \"../__chunks/4R3V3JGP.js\";\n\n// src/menu/menu-provider.tsx\nimport { jsx } from \"react/jsx-runtime\";\nfunction MenuProvider(props = {}) {\n  const store = useMenuStore(props);\n  return /* @__PURE__ */ jsx(MenuContextProvider, { value: store, children: props.children });\n}\nexport {\n  MenuProvider\n};\n","\"use client\";\nimport {\n  MenuScopedContextProvider,\n  useMenuProviderContext\n} from \"./IG6NVGLB.js\";\nimport {\n  useCompositeTypeahead\n} from \"./DMSZFK7W.js\";\nimport {\n  useComposite\n} from \"./FTNKYK65.js\";\nimport {\n  isHidden\n} from \"./RQZGFHI2.js\";\nimport {\n  createElement,\n  createHook,\n  forwardRef\n} from \"./5M6RSQEC.js\";\nimport {\n  useStoreState\n} from \"./EKQEJRUF.js\";\nimport {\n  useEvent,\n  useId,\n  useMergeRefs,\n  useWrapElement\n} from \"./6O5OEQGF.js\";\nimport {\n  __objRest,\n  __spreadProps,\n  __spreadValues\n} from \"./4R3V3JGP.js\";\n\n// src/menu/menu-list.tsx\nimport { useEffect, useState } from \"react\";\nimport { invariant } from \"@ariakit/core/utils/misc\";\nimport { jsx } from \"react/jsx-runtime\";\nvar TagName = \"div\";\nfunction useAriaLabelledBy(_a) {\n  var _b = _a, { store } = _b, props = __objRest(_b, [\"store\"]);\n  const [id, setId] = useState(void 0);\n  const label = props[\"aria-label\"];\n  const disclosureElement = useStoreState(store, \"disclosureElement\");\n  const contentElement = useStoreState(store, \"contentElement\");\n  useEffect(() => {\n    const disclosure = disclosureElement;\n    if (!disclosure)\n      return;\n    const menu = contentElement;\n    if (!menu)\n      return;\n    const menuLabel = label || menu.hasAttribute(\"aria-label\");\n    if (menuLabel) {\n      setId(void 0);\n    } else if (disclosure.id) {\n      setId(disclosure.id);\n    }\n  }, [label, disclosureElement, contentElement]);\n  return id;\n}\nvar useMenuList = createHook(\n  function useMenuList2(_a) {\n    var _b = _a, { store, alwaysVisible, composite } = _b, props = __objRest(_b, [\"store\", \"alwaysVisible\", \"composite\"]);\n    const context = useMenuProviderContext();\n    store = store || context;\n    invariant(\n      store,\n      process.env.NODE_ENV !== \"production\" && \"MenuList must receive a `store` prop or be wrapped in a MenuProvider component.\"\n    );\n    const parentMenu = store.parent;\n    const parentMenubar = store.menubar;\n    const hasParentMenu = !!parentMenu;\n    const id = useId(props.id);\n    const onKeyDownProp = props.onKeyDown;\n    const dir = store.useState(\n      (state) => state.placement.split(\"-\")[0]\n    );\n    const orientation = store.useState(\n      (state) => state.orientation === \"both\" ? void 0 : state.orientation\n    );\n    const isHorizontal = orientation !== \"vertical\";\n    const isMenubarHorizontal = useStoreState(\n      parentMenubar,\n      (state) => !!state && state.orientation !== \"vertical\"\n    );\n    const onKeyDown = useEvent((event) => {\n      onKeyDownProp == null ? void 0 : onKeyDownProp(event);\n      if (event.defaultPrevented)\n        return;\n      if (hasParentMenu || parentMenubar && !isHorizontal) {\n        const hideMap = {\n          ArrowRight: () => dir === \"left\" && !isHorizontal,\n          ArrowLeft: () => dir === \"right\" && !isHorizontal,\n          ArrowUp: () => dir === \"bottom\" && isHorizontal,\n          ArrowDown: () => dir === \"top\" && isHorizontal\n        };\n        const action = hideMap[event.key];\n        if (action == null ? void 0 : action()) {\n          event.stopPropagation();\n          event.preventDefault();\n          return store == null ? void 0 : store.hide();\n        }\n      }\n      if (parentMenubar) {\n        const keyMap = {\n          ArrowRight: () => {\n            if (!isMenubarHorizontal)\n              return;\n            return parentMenubar.next();\n          },\n          ArrowLeft: () => {\n            if (!isMenubarHorizontal)\n              return;\n            return parentMenubar.previous();\n          },\n          ArrowDown: () => {\n            if (isMenubarHorizontal)\n              return;\n            return parentMenubar.next();\n          },\n          ArrowUp: () => {\n            if (isMenubarHorizontal)\n              return;\n            return parentMenubar.previous();\n          }\n        };\n        const action = keyMap[event.key];\n        const id2 = action == null ? void 0 : action();\n        if (id2 !== void 0) {\n          event.stopPropagation();\n          event.preventDefault();\n          parentMenubar.move(id2);\n        }\n      }\n    });\n    props = useWrapElement(\n      props,\n      (element) => /* @__PURE__ */ jsx(MenuScopedContextProvider, { value: store, children: element }),\n      [store]\n    );\n    const ariaLabelledBy = useAriaLabelledBy(__spreadValues({ store }, props));\n    const mounted = store.useState(\"mounted\");\n    const hidden = isHidden(mounted, props.hidden, alwaysVisible);\n    const style = hidden ? __spreadProps(__spreadValues({}, props.style), { display: \"none\" }) : props.style;\n    props = __spreadProps(__spreadValues({\n      id,\n      \"aria-labelledby\": ariaLabelledBy,\n      hidden\n    }, props), {\n      ref: useMergeRefs(id ? store.setContentElement : null, props.ref),\n      style,\n      onKeyDown\n    });\n    const hasCombobox = !!store.combobox;\n    composite = composite != null ? composite : !hasCombobox;\n    if (composite) {\n      props = __spreadValues({\n        role: \"menu\",\n        \"aria-orientation\": orientation\n      }, props);\n    }\n    props = useComposite(__spreadValues({ store, composite }, props));\n    props = useCompositeTypeahead(__spreadValues({ store, typeahead: !hasCombobox }, props));\n    return props;\n  }\n);\nvar MenuList = forwardRef(function MenuList2(props) {\n  const htmlProps = useMenuList(props);\n  return createElement(TagName, htmlProps);\n});\n\nexport {\n  useMenuList,\n  MenuList\n};\n","\"use client\";\nimport {\n  useMenuList\n} from \"../__chunks/EF4Q2SSO.js\";\nimport {\n  useMenuProviderContext\n} from \"../__chunks/IG6NVGLB.js\";\nimport \"../__chunks/VBF5EZBB.js\";\nimport \"../__chunks/DMSZFK7W.js\";\nimport \"../__chunks/FTNKYK65.js\";\nimport \"../__chunks/3IEDWLST.js\";\nimport \"../__chunks/3D6OCOHF.js\";\nimport \"../__chunks/MADQZZRL.js\";\nimport {\n  useHovercard\n} from \"../__chunks/6YZEXKNV.js\";\nimport \"../__chunks/YMV43K4F.js\";\nimport \"../__chunks/BYD75WXE.js\";\nimport {\n  createDialogComponent\n} from \"../__chunks/KXSO5EFT.js\";\nimport \"../__chunks/3N4FFVWW.js\";\nimport \"../__chunks/NOYDL3YS.js\";\nimport \"../__chunks/BULCTPRV.js\";\nimport \"../__chunks/6BJGLK2C.js\";\nimport \"../__chunks/CS347UVZ.js\";\nimport \"../__chunks/IUB2BTEK.js\";\nimport \"../__chunks/XHJGS6Z5.js\";\nimport \"../__chunks/TL67WVI6.js\";\nimport \"../__chunks/MKDDWKFK.js\";\nimport \"../__chunks/72E5EPFF.js\";\nimport \"../__chunks/OOBDFMJL.js\";\nimport \"../__chunks/X6WIMZJE.js\";\nimport \"../__chunks/677M2CI3.js\";\nimport \"../__chunks/6GXEOXGT.js\";\nimport \"../__chunks/WCIYB4YS.js\";\nimport \"../__chunks/UYRJLDVS.js\";\nimport \"../__chunks/CK3UW3AQ.js\";\nimport \"../__chunks/WKWX2XLD.js\";\nimport \"../__chunks/7452U3HH.js\";\nimport \"../__chunks/XPF5GU3Q.js\";\nimport \"../__chunks/CBTO7DFZ.js\";\nimport \"../__chunks/RQZGFHI2.js\";\nimport \"../__chunks/TWDHCE7Y.js\";\nimport \"../__chunks/TE637IA7.js\";\nimport \"../__chunks/XXVAHUAO.js\";\nimport \"../__chunks/J55AVALY.js\";\nimport \"../__chunks/WAZE6NXP.js\";\nimport \"../__chunks/SHA3WOPI.js\";\nimport \"../__chunks/IFT5JEUU.js\";\nimport {\n  createElement,\n  createHook,\n  forwardRef\n} from \"../__chunks/5M6RSQEC.js\";\nimport \"../__chunks/I62TROYO.js\";\nimport \"../__chunks/HZJ2XALY.js\";\nimport {\n  useStoreState\n} from \"../__chunks/EKQEJRUF.js\";\nimport {\n  useMergeRefs\n} from \"../__chunks/6O5OEQGF.js\";\nimport \"../__chunks/XM66DUTO.js\";\nimport {\n  __objRest,\n  __spreadProps,\n  __spreadValues\n} from \"../__chunks/4R3V3JGP.js\";\n\n// src/menu/menu.tsx\nimport { createRef, useEffect, useMemo, useRef, useState } from \"react\";\nimport { fireEvent } from \"@ariakit/core/utils/events\";\nimport { hasFocusWithin } from \"@ariakit/core/utils/focus\";\nimport { invariant, isFalsyBooleanCallback } from \"@ariakit/core/utils/misc\";\nvar TagName = \"div\";\nvar useMenu = createHook(function useMenu2(_a) {\n  var _b = _a, {\n    store,\n    modal: modalProp = false,\n    portal = !!modalProp,\n    hideOnEscape = true,\n    autoFocusOnShow = true,\n    hideOnHoverOutside,\n    alwaysVisible\n  } = _b, props = __objRest(_b, [\n    \"store\",\n    \"modal\",\n    \"portal\",\n    \"hideOnEscape\",\n    \"autoFocusOnShow\",\n    \"hideOnHoverOutside\",\n    \"alwaysVisible\"\n  ]);\n  const context = useMenuProviderContext();\n  store = store || context;\n  invariant(\n    store,\n    process.env.NODE_ENV !== \"production\" && \"Menu must receive a `store` prop or be wrapped in a MenuProvider component.\"\n  );\n  const ref = useRef(null);\n  const parentMenu = store.parent;\n  const parentMenubar = store.menubar;\n  const hasParentMenu = !!parentMenu;\n  const parentIsMenubar = !!parentMenubar && !hasParentMenu;\n  props = __spreadProps(__spreadValues({}, props), {\n    ref: useMergeRefs(ref, props.ref)\n  });\n  const _a2 = useMenuList(__spreadValues({\n    store,\n    alwaysVisible\n  }, props)), { \"aria-labelledby\": ariaLabelledBy } = _a2, menuListProps = __objRest(_a2, [\"aria-labelledby\"]);\n  props = menuListProps;\n  const [initialFocusRef, setInitialFocusRef] = useState();\n  const autoFocusOnShowState = store.useState(\"autoFocusOnShow\");\n  const initialFocus = store.useState(\"initialFocus\");\n  const baseElement = store.useState(\"baseElement\");\n  const items = store.useState(\"renderedItems\");\n  useEffect(() => {\n    let cleaning = false;\n    setInitialFocusRef((prevInitialFocusRef) => {\n      var _a3, _b2, _c;\n      if (cleaning)\n        return;\n      if (!autoFocusOnShowState)\n        return;\n      if ((_a3 = prevInitialFocusRef == null ? void 0 : prevInitialFocusRef.current) == null ? void 0 : _a3.isConnected)\n        return prevInitialFocusRef;\n      const ref2 = createRef();\n      switch (initialFocus) {\n        case \"first\":\n          ref2.current = ((_b2 = items.find((item) => !item.disabled && item.element)) == null ? void 0 : _b2.element) || null;\n          break;\n        case \"last\":\n          ref2.current = ((_c = [...items].reverse().find((item) => !item.disabled && item.element)) == null ? void 0 : _c.element) || null;\n          break;\n        default:\n          ref2.current = baseElement;\n      }\n      return ref2;\n    });\n    return () => {\n      cleaning = true;\n    };\n  }, [store, autoFocusOnShowState, initialFocus, items, baseElement]);\n  const modal = hasParentMenu ? false : modalProp;\n  const mayAutoFocusOnShow = !!autoFocusOnShow;\n  const canAutoFocusOnShow = !!initialFocusRef || !!props.initialFocus || !!modal;\n  const contentElement = useStoreState(\n    store.combobox || store,\n    \"contentElement\"\n  );\n  const parentContentElement = useStoreState(\n    (parentMenu == null ? void 0 : parentMenu.combobox) || parentMenu,\n    \"contentElement\"\n  );\n  const preserveTabOrderAnchor = useMemo(() => {\n    if (!parentContentElement)\n      return;\n    if (!contentElement)\n      return;\n    const role = contentElement.getAttribute(\"role\");\n    const parentRole = parentContentElement.getAttribute(\"role\");\n    const parentIsMenuOrMenubar = parentRole === \"menu\" || parentRole === \"menubar\";\n    if (parentIsMenuOrMenubar && role === \"menu\")\n      return;\n    return parentContentElement;\n  }, [contentElement, parentContentElement]);\n  if (preserveTabOrderAnchor !== void 0) {\n    props = __spreadValues({\n      preserveTabOrderAnchor\n    }, props);\n  }\n  props = useHovercard(__spreadProps(__spreadValues({\n    store,\n    alwaysVisible,\n    initialFocus: initialFocusRef,\n    autoFocusOnShow: mayAutoFocusOnShow ? canAutoFocusOnShow && autoFocusOnShow : autoFocusOnShowState || !!modal\n  }, props), {\n    hideOnEscape(event) {\n      if (isFalsyBooleanCallback(hideOnEscape, event))\n        return false;\n      store == null ? void 0 : store.hideAll();\n      return true;\n    },\n    hideOnHoverOutside(event) {\n      const disclosureElement = store == null ? void 0 : store.getState().disclosureElement;\n      const getHideOnHoverOutside = () => {\n        if (typeof hideOnHoverOutside === \"function\") {\n          return hideOnHoverOutside(event);\n        }\n        if (hideOnHoverOutside != null)\n          return hideOnHoverOutside;\n        if (hasParentMenu)\n          return true;\n        if (!parentIsMenubar)\n          return false;\n        if (!disclosureElement)\n          return true;\n        if (hasFocusWithin(disclosureElement))\n          return false;\n        return true;\n      };\n      if (!getHideOnHoverOutside())\n        return false;\n      if (event.defaultPrevented)\n        return true;\n      if (!hasParentMenu)\n        return true;\n      if (!disclosureElement)\n        return true;\n      fireEvent(disclosureElement, \"mouseout\", event);\n      if (!hasFocusWithin(disclosureElement))\n        return true;\n      requestAnimationFrame(() => {\n        if (hasFocusWithin(disclosureElement))\n          return;\n        store == null ? void 0 : store.hide();\n      });\n      return false;\n    },\n    modal,\n    portal,\n    backdrop: hasParentMenu ? false : props.backdrop\n  }));\n  props = __spreadValues({\n    \"aria-labelledby\": ariaLabelledBy\n  }, props);\n  return props;\n});\nvar Menu = createDialogComponent(\n  forwardRef(function Menu2(props) {\n    const htmlProps = useMenu(props);\n    return createElement(TagName, htmlProps);\n  }),\n  useMenuProviderContext\n);\nexport {\n  Menu,\n  useMenu\n};\n","\"use client\";\nimport {\n  TabScopedContextProvider,\n  useTabProviderContext\n} from \"../__chunks/32VQXIYR.js\";\nimport {\n  useComposite\n} from \"../__chunks/FTNKYK65.js\";\nimport \"../__chunks/3IEDWLST.js\";\nimport \"../__chunks/3D6OCOHF.js\";\nimport \"../__chunks/MADQZZRL.js\";\nimport \"../__chunks/WAZE6NXP.js\";\nimport \"../__chunks/SHA3WOPI.js\";\nimport {\n  createElement,\n  createHook,\n  forwardRef\n} from \"../__chunks/5M6RSQEC.js\";\nimport {\n  useWrapElement\n} from \"../__chunks/6O5OEQGF.js\";\nimport \"../__chunks/XM66DUTO.js\";\nimport {\n  __objRest,\n  __spreadValues\n} from \"../__chunks/4R3V3JGP.js\";\n\n// src/tab/tab-list.tsx\nimport { invariant } from \"@ariakit/core/utils/misc\";\nimport { jsx } from \"react/jsx-runtime\";\nvar TagName = \"div\";\nvar useTabList = createHook(\n  function useTabList2(_a) {\n    var _b = _a, { store } = _b, props = __objRest(_b, [\"store\"]);\n    const context = useTabProviderContext();\n    store = store || context;\n    invariant(\n      store,\n      process.env.NODE_ENV !== \"production\" && \"TabList must receive a `store` prop or be wrapped in a TabProvider component.\"\n    );\n    const orientation = store.useState(\n      (state) => state.orientation === \"both\" ? void 0 : state.orientation\n    );\n    props = useWrapElement(\n      props,\n      (element) => /* @__PURE__ */ jsx(TabScopedContextProvider, { value: store, children: element }),\n      [store]\n    );\n    props = __spreadValues({\n      role: \"tablist\",\n      \"aria-orientation\": orientation\n    }, props);\n    props = useComposite(__spreadValues({ store }, props));\n    return props;\n  }\n);\nvar TabList = forwardRef(function TabList2(props) {\n  const htmlProps = useTabList(props);\n  return createElement(TagName, htmlProps);\n});\nexport {\n  TabList,\n  useTabList\n};\n","\"use client\";\nimport {\n  useCollectionItem\n} from \"../__chunks/7YKLTEOQ.js\";\nimport {\n  TabScopedContextProvider,\n  useTabProviderContext\n} from \"../__chunks/32VQXIYR.js\";\nimport \"../__chunks/3D6OCOHF.js\";\nimport \"../__chunks/MADQZZRL.js\";\nimport {\n  useDisclosureContent\n} from \"../__chunks/RQZGFHI2.js\";\nimport \"../__chunks/XXVAHUAO.js\";\nimport \"../__chunks/J55AVALY.js\";\nimport {\n  useFocusable\n} from \"../__chunks/WAZE6NXP.js\";\nimport \"../__chunks/SHA3WOPI.js\";\nimport {\n  createElement,\n  createHook,\n  forwardRef\n} from \"../__chunks/5M6RSQEC.js\";\nimport {\n  useDisclosureStore\n} from \"../__chunks/HZJ2XALY.js\";\nimport \"../__chunks/EKQEJRUF.js\";\nimport {\n  useId,\n  useMergeRefs,\n  useWrapElement\n} from \"../__chunks/6O5OEQGF.js\";\nimport \"../__chunks/XM66DUTO.js\";\nimport {\n  __objRest,\n  __spreadProps,\n  __spreadValues\n} from \"../__chunks/4R3V3JGP.js\";\n\n// src/tab/tab-panel.tsx\nimport { useCallback, useEffect, useRef, useState } from \"react\";\nimport { getAllTabbableIn } from \"@ariakit/core/utils/focus\";\nimport { invariant } from \"@ariakit/core/utils/misc\";\nimport { jsx } from \"react/jsx-runtime\";\nvar TagName = \"div\";\nvar useTabPanel = createHook(\n  function useTabPanel2(_a) {\n    var _b = _a, {\n      store,\n      tabId: tabIdProp,\n      getItem: getItemProp\n    } = _b, props = __objRest(_b, [\n      \"store\",\n      \"tabId\",\n      \"getItem\"\n    ]);\n    const context = useTabProviderContext();\n    store = store || context;\n    invariant(\n      store,\n      process.env.NODE_ENV !== \"production\" && \"TabPanel must receive a `store` prop or be wrapped in a TabProvider component.\"\n    );\n    const ref = useRef(null);\n    const id = useId(props.id);\n    const [hasTabbableChildren, setHasTabbableChildren] = useState(false);\n    useEffect(() => {\n      const element = ref.current;\n      if (!element)\n        return;\n      const tabbable = getAllTabbableIn(element);\n      setHasTabbableChildren(!!tabbable.length);\n    }, []);\n    const getItem = useCallback(\n      (item) => {\n        const nextItem = __spreadProps(__spreadValues({}, item), { id: id || item.id, tabId: tabIdProp });\n        if (getItemProp) {\n          return getItemProp(nextItem);\n        }\n        return nextItem;\n      },\n      [id, tabIdProp, getItemProp]\n    );\n    props = useWrapElement(\n      props,\n      (element) => /* @__PURE__ */ jsx(TabScopedContextProvider, { value: store, children: element }),\n      [store]\n    );\n    const tabId = store.panels.useState(\n      () => {\n        var _a2;\n        return tabIdProp || ((_a2 = store == null ? void 0 : store.panels.item(id)) == null ? void 0 : _a2.tabId);\n      }\n    );\n    const open = store.useState(\n      (state) => !!tabId && state.selectedId === tabId\n    );\n    props = __spreadProps(__spreadValues({\n      id,\n      role: \"tabpanel\",\n      \"aria-labelledby\": tabId || void 0\n    }, props), {\n      ref: useMergeRefs(ref, props.ref)\n    });\n    const disclosure = useDisclosureStore({ open });\n    props = useFocusable(__spreadValues({ focusable: !hasTabbableChildren }, props));\n    props = useDisclosureContent(__spreadValues({ store: disclosure }, props));\n    props = useCollectionItem(__spreadProps(__spreadValues({ store: store.panels }, props), { getItem }));\n    return props;\n  }\n);\nvar TabPanel = forwardRef(function TabPanel2(props) {\n  const htmlProps = useTabPanel(props);\n  return createElement(TagName, htmlProps);\n});\nexport {\n  TabPanel,\n  useTabPanel\n};\n","\"use client\";\nimport {\n  createCompositeStore\n} from \"../__chunks/2H5K47H4.js\";\nimport {\n  createCollectionStore\n} from \"../__chunks/URUD7X4C.js\";\nimport {\n  batch,\n  createStore,\n  setup,\n  sync\n} from \"../__chunks/R676XYVY.js\";\nimport {\n  defaultValue\n} from \"../__chunks/22HHDS5F.js\";\nimport \"../__chunks/RRSZHCH6.js\";\nimport \"../__chunks/7PRQYBBV.js\";\nimport {\n  __spreadProps,\n  __spreadValues\n} from \"../__chunks/4R3V3JGP.js\";\n\n// src/tab/tab-store.ts\nfunction createTabStore(props = {}) {\n  var _a;\n  const syncState = (_a = props.store) == null ? void 0 : _a.getState();\n  const composite = createCompositeStore(__spreadProps(__spreadValues({}, props), {\n    orientation: defaultValue(\n      props.orientation,\n      syncState == null ? void 0 : syncState.orientation,\n      \"horizontal\"\n    ),\n    focusLoop: defaultValue(props.focusLoop, syncState == null ? void 0 : syncState.focusLoop, true)\n  }));\n  const panels = createCollectionStore();\n  const initialState = __spreadProps(__spreadValues({}, composite.getState()), {\n    selectedId: defaultValue(\n      props.selectedId,\n      syncState == null ? void 0 : syncState.selectedId,\n      props.defaultSelectedId,\n      void 0\n    ),\n    selectOnMove: defaultValue(\n      props.selectOnMove,\n      syncState == null ? void 0 : syncState.selectOnMove,\n      true\n    )\n  });\n  const tab = createStore(initialState, composite, props.store);\n  setup(\n    tab,\n    () => sync(tab, [\"moves\"], () => {\n      const { activeId, selectOnMove } = tab.getState();\n      if (!selectOnMove)\n        return;\n      if (!activeId)\n        return;\n      const tabItem = composite.item(activeId);\n      if (!tabItem)\n        return;\n      if (tabItem.dimmed)\n        return;\n      if (tabItem.disabled)\n        return;\n      tab.setState(\"selectedId\", tabItem.id);\n    })\n  );\n  setup(\n    tab,\n    () => batch(\n      tab,\n      [\"selectedId\"],\n      (state) => tab.setState(\"activeId\", state.selectedId)\n    )\n  );\n  setup(\n    tab,\n    () => sync(tab, [\"selectedId\", \"renderedItems\"], (state) => {\n      if (state.selectedId !== void 0)\n        return;\n      const { activeId, renderedItems } = tab.getState();\n      const tabItem = composite.item(activeId);\n      if (tabItem && !tabItem.disabled && !tabItem.dimmed) {\n        tab.setState(\"selectedId\", tabItem.id);\n      } else {\n        const tabItem2 = renderedItems.find(\n          (item) => !item.disabled && !item.dimmed\n        );\n        tab.setState(\"selectedId\", tabItem2 == null ? void 0 : tabItem2.id);\n      }\n    })\n  );\n  setup(\n    tab,\n    () => sync(tab, [\"renderedItems\"], (state) => {\n      const tabs = state.renderedItems;\n      if (!tabs.length)\n        return;\n      return sync(panels, [\"renderedItems\"], (state2) => {\n        const items = state2.renderedItems;\n        const hasOrphanPanels = items.some((panel) => !panel.tabId);\n        if (!hasOrphanPanels)\n          return;\n        items.forEach((panel, i) => {\n          if (panel.tabId)\n            return;\n          const tabItem = tabs[i];\n          if (!tabItem)\n            return;\n          panels.renderItem(__spreadProps(__spreadValues({}, panel), { tabId: tabItem.id }));\n        });\n      });\n    })\n  );\n  return __spreadProps(__spreadValues(__spreadValues({}, composite), tab), {\n    panels,\n    setSelectedId: (id) => tab.setState(\"selectedId\", id),\n    select: (id) => {\n      tab.setState(\"selectedId\", id);\n      composite.move(id);\n    }\n  });\n}\nexport {\n  createTabStore\n};\n","\"use client\";\nimport {\n  useCompositeStoreProps\n} from \"./7GBW5FLS.js\";\nimport {\n  useStore,\n  useStoreProps\n} from \"./EKQEJRUF.js\";\nimport {\n  useUpdateEffect\n} from \"./6O5OEQGF.js\";\nimport {\n  __spreadProps,\n  __spreadValues\n} from \"./4R3V3JGP.js\";\n\n// src/tab/tab-store.ts\nimport { useMemo } from \"react\";\nimport * as Core from \"@ariakit/core/tab/tab-store\";\nfunction useTabStoreProps(store, update, props) {\n  store = useCompositeStoreProps(store, update, props);\n  useStoreProps(store, props, \"selectedId\", \"setSelectedId\");\n  useStoreProps(store, props, \"selectOnMove\");\n  const [panels, updatePanels] = useStore(() => store.panels, {});\n  useUpdateEffect(updatePanels, [store, updatePanels]);\n  return useMemo(() => __spreadProps(__spreadValues({}, store), { panels }), [store, panels]);\n}\nfunction useTabStore(props = {}) {\n  const [store, update] = useStore(Core.createTabStore, props);\n  return useTabStoreProps(store, update, props);\n}\n\nexport {\n  useTabStoreProps,\n  useTabStore\n};\n","\"use client\";\nimport {\n  useTabStore\n} from \"../__chunks/CQMDBRG5.js\";\nimport {\n  TabContextProvider\n} from \"../__chunks/32VQXIYR.js\";\nimport \"../__chunks/7GBW5FLS.js\";\nimport \"../__chunks/Y6GYTNQ2.js\";\nimport \"../__chunks/3D6OCOHF.js\";\nimport \"../__chunks/MADQZZRL.js\";\nimport \"../__chunks/5M6RSQEC.js\";\nimport \"../__chunks/EKQEJRUF.js\";\nimport \"../__chunks/6O5OEQGF.js\";\nimport \"../__chunks/XM66DUTO.js\";\nimport \"../__chunks/4R3V3JGP.js\";\n\n// src/tab/tab-provider.tsx\nimport { jsx } from \"react/jsx-runtime\";\nfunction TabProvider(props = {}) {\n  const store = useTabStore(props);\n  return /* @__PURE__ */ jsx(TabContextProvider, { value: store, children: props.children });\n}\nexport {\n  TabProvider\n};\n","\"use client\";\nimport {\n  useCompositeItem\n} from \"../__chunks/C6OBNQ4F.js\";\nimport \"../__chunks/KSZPJCUA.js\";\nimport \"../__chunks/7YKLTEOQ.js\";\nimport {\n  useTabScopedContext\n} from \"../__chunks/32VQXIYR.js\";\nimport \"../__chunks/3IEDWLST.js\";\nimport \"../__chunks/3D6OCOHF.js\";\nimport \"../__chunks/MADQZZRL.js\";\nimport \"../__chunks/WAZE6NXP.js\";\nimport \"../__chunks/SHA3WOPI.js\";\nimport {\n  createElement,\n  createHook,\n  forwardRef,\n  memo\n} from \"../__chunks/5M6RSQEC.js\";\nimport \"../__chunks/EKQEJRUF.js\";\nimport {\n  useEvent,\n  useId\n} from \"../__chunks/6O5OEQGF.js\";\nimport \"../__chunks/XM66DUTO.js\";\nimport {\n  __objRest,\n  __spreadProps,\n  __spreadValues\n} from \"../__chunks/4R3V3JGP.js\";\n\n// src/tab/tab.ts\nimport { useCallback } from \"react\";\nimport { disabledFromProps, invariant } from \"@ariakit/core/utils/misc\";\nvar TagName = \"button\";\nvar useTab = createHook(function useTab2(_a) {\n  var _b = _a, {\n    store,\n    accessibleWhenDisabled = true,\n    getItem: getItemProp\n  } = _b, props = __objRest(_b, [\n    \"store\",\n    \"accessibleWhenDisabled\",\n    \"getItem\"\n  ]);\n  const context = useTabScopedContext();\n  store = store || context;\n  invariant(\n    store,\n    process.env.NODE_ENV !== \"production\" && \"Tab must be wrapped in a TabList component.\"\n  );\n  const defaultId = useId();\n  const id = props.id || defaultId;\n  const dimmed = disabledFromProps(props);\n  const getItem = useCallback(\n    (item) => {\n      const nextItem = __spreadProps(__spreadValues({}, item), { dimmed });\n      if (getItemProp) {\n        return getItemProp(nextItem);\n      }\n      return nextItem;\n    },\n    [dimmed, getItemProp]\n  );\n  const onClickProp = props.onClick;\n  const onClick = useEvent((event) => {\n    onClickProp == null ? void 0 : onClickProp(event);\n    if (event.defaultPrevented)\n      return;\n    store == null ? void 0 : store.setSelectedId(id);\n  });\n  const panelId = store.panels.useState(\n    (state) => {\n      var _a2;\n      return (_a2 = state.items.find((item) => item.tabId === id)) == null ? void 0 : _a2.id;\n    }\n  );\n  const selected = store.useState((state) => !!id && state.selectedId === id);\n  props = __spreadProps(__spreadValues({\n    id,\n    role: \"tab\",\n    \"aria-selected\": selected,\n    \"aria-controls\": panelId || void 0\n  }, props), {\n    onClick\n  });\n  props = useCompositeItem(__spreadProps(__spreadValues({\n    store\n  }, props), {\n    accessibleWhenDisabled,\n    getItem,\n    shouldRegisterItem: !!defaultId ? props.shouldRegisterItem : false\n  }));\n  return props;\n});\nvar Tab = memo(\n  forwardRef(function Tab2(props) {\n    const htmlProps = useTab(props);\n    return createElement(TagName, htmlProps);\n  })\n);\nexport {\n  Tab,\n  useTab\n};\n","import { Bezier } from \"./bezier.js\";\n\n// math-inlining.\nconst { abs, cos, sin, acos, atan2, sqrt, pow } = Math;\n\n// cube root function yielding real roots\nfunction crt(v) {\n  return v < 0 ? -pow(-v, 1 / 3) : pow(v, 1 / 3);\n}\n\n// trig constants\nconst pi = Math.PI,\n  tau = 2 * pi,\n  quart = pi / 2,\n  // float precision significant decimal\n  epsilon = 0.000001,\n  // extremas used in bbox calculation and similar algorithms\n  nMax = Number.MAX_SAFE_INTEGER || 9007199254740991,\n  nMin = Number.MIN_SAFE_INTEGER || -9007199254740991,\n  // a zero coordinate, which is surprisingly useful\n  ZERO = { x: 0, y: 0, z: 0 };\n\n// Bezier utility functions\nconst utils = {\n  // Legendre-Gauss abscissae with n=24 (x_i values, defined at i=n as the roots of the nth order Legendre polynomial Pn(x))\n  Tvalues: [\n    -0.0640568928626056260850430826247450385909,\n    0.0640568928626056260850430826247450385909,\n    -0.1911188674736163091586398207570696318404,\n    0.1911188674736163091586398207570696318404,\n    -0.3150426796961633743867932913198102407864,\n    0.3150426796961633743867932913198102407864,\n    -0.4337935076260451384870842319133497124524,\n    0.4337935076260451384870842319133497124524,\n    -0.5454214713888395356583756172183723700107,\n    0.5454214713888395356583756172183723700107,\n    -0.6480936519369755692524957869107476266696,\n    0.6480936519369755692524957869107476266696,\n    -0.7401241915785543642438281030999784255232,\n    0.7401241915785543642438281030999784255232,\n    -0.8200019859739029219539498726697452080761,\n    0.8200019859739029219539498726697452080761,\n    -0.8864155270044010342131543419821967550873,\n    0.8864155270044010342131543419821967550873,\n    -0.9382745520027327585236490017087214496548,\n    0.9382745520027327585236490017087214496548,\n    -0.9747285559713094981983919930081690617411,\n    0.9747285559713094981983919930081690617411,\n    -0.9951872199970213601799974097007368118745,\n    0.9951872199970213601799974097007368118745,\n  ],\n\n  // Legendre-Gauss weights with n=24 (w_i values, defined by a function linked to in the Bezier primer article)\n  Cvalues: [\n    0.1279381953467521569740561652246953718517,\n    0.1279381953467521569740561652246953718517,\n    0.1258374563468282961213753825111836887264,\n    0.1258374563468282961213753825111836887264,\n    0.121670472927803391204463153476262425607,\n    0.121670472927803391204463153476262425607,\n    0.1155056680537256013533444839067835598622,\n    0.1155056680537256013533444839067835598622,\n    0.1074442701159656347825773424466062227946,\n    0.1074442701159656347825773424466062227946,\n    0.0976186521041138882698806644642471544279,\n    0.0976186521041138882698806644642471544279,\n    0.086190161531953275917185202983742667185,\n    0.086190161531953275917185202983742667185,\n    0.0733464814110803057340336152531165181193,\n    0.0733464814110803057340336152531165181193,\n    0.0592985849154367807463677585001085845412,\n    0.0592985849154367807463677585001085845412,\n    0.0442774388174198061686027482113382288593,\n    0.0442774388174198061686027482113382288593,\n    0.0285313886289336631813078159518782864491,\n    0.0285313886289336631813078159518782864491,\n    0.0123412297999871995468056670700372915759,\n    0.0123412297999871995468056670700372915759,\n  ],\n\n  arcfn: function (t, derivativeFn) {\n    const d = derivativeFn(t);\n    let l = d.x * d.x + d.y * d.y;\n    if (typeof d.z !== \"undefined\") {\n      l += d.z * d.z;\n    }\n    return sqrt(l);\n  },\n\n  compute: function (t, points, _3d) {\n    // shortcuts\n    if (t === 0) {\n      points[0].t = 0;\n      return points[0];\n    }\n\n    const order = points.length - 1;\n\n    if (t === 1) {\n      points[order].t = 1;\n      return points[order];\n    }\n\n    const mt = 1 - t;\n    let p = points;\n\n    // constant?\n    if (order === 0) {\n      points[0].t = t;\n      return points[0];\n    }\n\n    // linear?\n    if (order === 1) {\n      const ret = {\n        x: mt * p[0].x + t * p[1].x,\n        y: mt * p[0].y + t * p[1].y,\n        t: t,\n      };\n      if (_3d) {\n        ret.z = mt * p[0].z + t * p[1].z;\n      }\n      return ret;\n    }\n\n    // quadratic/cubic curve?\n    if (order < 4) {\n      let mt2 = mt * mt,\n        t2 = t * t,\n        a,\n        b,\n        c,\n        d = 0;\n      if (order === 2) {\n        p = [p[0], p[1], p[2], ZERO];\n        a = mt2;\n        b = mt * t * 2;\n        c = t2;\n      } else if (order === 3) {\n        a = mt2 * mt;\n        b = mt2 * t * 3;\n        c = mt * t2 * 3;\n        d = t * t2;\n      }\n      const ret = {\n        x: a * p[0].x + b * p[1].x + c * p[2].x + d * p[3].x,\n        y: a * p[0].y + b * p[1].y + c * p[2].y + d * p[3].y,\n        t: t,\n      };\n      if (_3d) {\n        ret.z = a * p[0].z + b * p[1].z + c * p[2].z + d * p[3].z;\n      }\n      return ret;\n    }\n\n    // higher order curves: use de Casteljau's computation\n    const dCpts = JSON.parse(JSON.stringify(points));\n    while (dCpts.length > 1) {\n      for (let i = 0; i < dCpts.length - 1; i++) {\n        dCpts[i] = {\n          x: dCpts[i].x + (dCpts[i + 1].x - dCpts[i].x) * t,\n          y: dCpts[i].y + (dCpts[i + 1].y - dCpts[i].y) * t,\n        };\n        if (typeof dCpts[i].z !== \"undefined\") {\n          dCpts[i] = dCpts[i].z + (dCpts[i + 1].z - dCpts[i].z) * t;\n        }\n      }\n      dCpts.splice(dCpts.length - 1, 1);\n    }\n    dCpts[0].t = t;\n    return dCpts[0];\n  },\n\n  computeWithRatios: function (t, points, ratios, _3d) {\n    const mt = 1 - t,\n      r = ratios,\n      p = points;\n\n    let f1 = r[0],\n      f2 = r[1],\n      f3 = r[2],\n      f4 = r[3],\n      d;\n\n    // spec for linear\n    f1 *= mt;\n    f2 *= t;\n\n    if (p.length === 2) {\n      d = f1 + f2;\n      return {\n        x: (f1 * p[0].x + f2 * p[1].x) / d,\n        y: (f1 * p[0].y + f2 * p[1].y) / d,\n        z: !_3d ? false : (f1 * p[0].z + f2 * p[1].z) / d,\n        t: t,\n      };\n    }\n\n    // upgrade to quadratic\n    f1 *= mt;\n    f2 *= 2 * mt;\n    f3 *= t * t;\n\n    if (p.length === 3) {\n      d = f1 + f2 + f3;\n      return {\n        x: (f1 * p[0].x + f2 * p[1].x + f3 * p[2].x) / d,\n        y: (f1 * p[0].y + f2 * p[1].y + f3 * p[2].y) / d,\n        z: !_3d ? false : (f1 * p[0].z + f2 * p[1].z + f3 * p[2].z) / d,\n        t: t,\n      };\n    }\n\n    // upgrade to cubic\n    f1 *= mt;\n    f2 *= 1.5 * mt;\n    f3 *= 3 * mt;\n    f4 *= t * t * t;\n\n    if (p.length === 4) {\n      d = f1 + f2 + f3 + f4;\n      return {\n        x: (f1 * p[0].x + f2 * p[1].x + f3 * p[2].x + f4 * p[3].x) / d,\n        y: (f1 * p[0].y + f2 * p[1].y + f3 * p[2].y + f4 * p[3].y) / d,\n        z: !_3d\n          ? false\n          : (f1 * p[0].z + f2 * p[1].z + f3 * p[2].z + f4 * p[3].z) / d,\n        t: t,\n      };\n    }\n  },\n\n  derive: function (points, _3d) {\n    const dpoints = [];\n    for (let p = points, d = p.length, c = d - 1; d > 1; d--, c--) {\n      const list = [];\n      for (let j = 0, dpt; j < c; j++) {\n        dpt = {\n          x: c * (p[j + 1].x - p[j].x),\n          y: c * (p[j + 1].y - p[j].y),\n        };\n        if (_3d) {\n          dpt.z = c * (p[j + 1].z - p[j].z);\n        }\n        list.push(dpt);\n      }\n      dpoints.push(list);\n      p = list;\n    }\n    return dpoints;\n  },\n\n  between: function (v, m, M) {\n    return (\n      (m <= v && v <= M) ||\n      utils.approximately(v, m) ||\n      utils.approximately(v, M)\n    );\n  },\n\n  approximately: function (a, b, precision) {\n    return abs(a - b) <= (precision || epsilon);\n  },\n\n  length: function (derivativeFn) {\n    const z = 0.5,\n      len = utils.Tvalues.length;\n\n    let sum = 0;\n\n    for (let i = 0, t; i < len; i++) {\n      t = z * utils.Tvalues[i] + z;\n      sum += utils.Cvalues[i] * utils.arcfn(t, derivativeFn);\n    }\n    return z * sum;\n  },\n\n  map: function (v, ds, de, ts, te) {\n    const d1 = de - ds,\n      d2 = te - ts,\n      v2 = v - ds,\n      r = v2 / d1;\n    return ts + d2 * r;\n  },\n\n  lerp: function (r, v1, v2) {\n    const ret = {\n      x: v1.x + r * (v2.x - v1.x),\n      y: v1.y + r * (v2.y - v1.y),\n    };\n    if (v1.z !== undefined && v2.z !== undefined) {\n      ret.z = v1.z + r * (v2.z - v1.z);\n    }\n    return ret;\n  },\n\n  pointToString: function (p) {\n    let s = p.x + \"/\" + p.y;\n    if (typeof p.z !== \"undefined\") {\n      s += \"/\" + p.z;\n    }\n    return s;\n  },\n\n  pointsToString: function (points) {\n    return \"[\" + points.map(utils.pointToString).join(\", \") + \"]\";\n  },\n\n  copy: function (obj) {\n    return JSON.parse(JSON.stringify(obj));\n  },\n\n  angle: function (o, v1, v2) {\n    const dx1 = v1.x - o.x,\n      dy1 = v1.y - o.y,\n      dx2 = v2.x - o.x,\n      dy2 = v2.y - o.y,\n      cross = dx1 * dy2 - dy1 * dx2,\n      dot = dx1 * dx2 + dy1 * dy2;\n    return atan2(cross, dot);\n  },\n\n  // round as string, to avoid rounding errors\n  round: function (v, d) {\n    const s = \"\" + v;\n    const pos = s.indexOf(\".\");\n    return parseFloat(s.substring(0, pos + 1 + d));\n  },\n\n  dist: function (p1, p2) {\n    const dx = p1.x - p2.x,\n      dy = p1.y - p2.y;\n    return sqrt(dx * dx + dy * dy);\n  },\n\n  closest: function (LUT, point) {\n    let mdist = pow(2, 63),\n      mpos,\n      d;\n    LUT.forEach(function (p, idx) {\n      d = utils.dist(point, p);\n      if (d < mdist) {\n        mdist = d;\n        mpos = idx;\n      }\n    });\n    return { mdist: mdist, mpos: mpos };\n  },\n\n  abcratio: function (t, n) {\n    // see ratio(t) note on http://pomax.github.io/bezierinfo/#abc\n    if (n !== 2 && n !== 3) {\n      return false;\n    }\n    if (typeof t === \"undefined\") {\n      t = 0.5;\n    } else if (t === 0 || t === 1) {\n      return t;\n    }\n    const bottom = pow(t, n) + pow(1 - t, n),\n      top = bottom - 1;\n    return abs(top / bottom);\n  },\n\n  projectionratio: function (t, n) {\n    // see u(t) note on http://pomax.github.io/bezierinfo/#abc\n    if (n !== 2 && n !== 3) {\n      return false;\n    }\n    if (typeof t === \"undefined\") {\n      t = 0.5;\n    } else if (t === 0 || t === 1) {\n      return t;\n    }\n    const top = pow(1 - t, n),\n      bottom = pow(t, n) + top;\n    return top / bottom;\n  },\n\n  lli8: function (x1, y1, x2, y2, x3, y3, x4, y4) {\n    const nx =\n        (x1 * y2 - y1 * x2) * (x3 - x4) - (x1 - x2) * (x3 * y4 - y3 * x4),\n      ny = (x1 * y2 - y1 * x2) * (y3 - y4) - (y1 - y2) * (x3 * y4 - y3 * x4),\n      d = (x1 - x2) * (y3 - y4) - (y1 - y2) * (x3 - x4);\n    if (d == 0) {\n      return false;\n    }\n    return { x: nx / d, y: ny / d };\n  },\n\n  lli4: function (p1, p2, p3, p4) {\n    const x1 = p1.x,\n      y1 = p1.y,\n      x2 = p2.x,\n      y2 = p2.y,\n      x3 = p3.x,\n      y3 = p3.y,\n      x4 = p4.x,\n      y4 = p4.y;\n    return utils.lli8(x1, y1, x2, y2, x3, y3, x4, y4);\n  },\n\n  lli: function (v1, v2) {\n    return utils.lli4(v1, v1.c, v2, v2.c);\n  },\n\n  makeline: function (p1, p2) {\n    const x1 = p1.x,\n      y1 = p1.y,\n      x2 = p2.x,\n      y2 = p2.y,\n      dx = (x2 - x1) / 3,\n      dy = (y2 - y1) / 3;\n    return new Bezier(\n      x1,\n      y1,\n      x1 + dx,\n      y1 + dy,\n      x1 + 2 * dx,\n      y1 + 2 * dy,\n      x2,\n      y2\n    );\n  },\n\n  findbbox: function (sections) {\n    let mx = nMax,\n      my = nMax,\n      MX = nMin,\n      MY = nMin;\n    sections.forEach(function (s) {\n      const bbox = s.bbox();\n      if (mx > bbox.x.min) mx = bbox.x.min;\n      if (my > bbox.y.min) my = bbox.y.min;\n      if (MX < bbox.x.max) MX = bbox.x.max;\n      if (MY < bbox.y.max) MY = bbox.y.max;\n    });\n    return {\n      x: { min: mx, mid: (mx + MX) / 2, max: MX, size: MX - mx },\n      y: { min: my, mid: (my + MY) / 2, max: MY, size: MY - my },\n    };\n  },\n\n  shapeintersections: function (\n    s1,\n    bbox1,\n    s2,\n    bbox2,\n    curveIntersectionThreshold\n  ) {\n    if (!utils.bboxoverlap(bbox1, bbox2)) return [];\n    const intersections = [];\n    const a1 = [s1.startcap, s1.forward, s1.back, s1.endcap];\n    const a2 = [s2.startcap, s2.forward, s2.back, s2.endcap];\n    a1.forEach(function (l1) {\n      if (l1.virtual) return;\n      a2.forEach(function (l2) {\n        if (l2.virtual) return;\n        const iss = l1.intersects(l2, curveIntersectionThreshold);\n        if (iss.length > 0) {\n          iss.c1 = l1;\n          iss.c2 = l2;\n          iss.s1 = s1;\n          iss.s2 = s2;\n          intersections.push(iss);\n        }\n      });\n    });\n    return intersections;\n  },\n\n  makeshape: function (forward, back, curveIntersectionThreshold) {\n    const bpl = back.points.length;\n    const fpl = forward.points.length;\n    const start = utils.makeline(back.points[bpl - 1], forward.points[0]);\n    const end = utils.makeline(forward.points[fpl - 1], back.points[0]);\n    const shape = {\n      startcap: start,\n      forward: forward,\n      back: back,\n      endcap: end,\n      bbox: utils.findbbox([start, forward, back, end]),\n    };\n    shape.intersections = function (s2) {\n      return utils.shapeintersections(\n        shape,\n        shape.bbox,\n        s2,\n        s2.bbox,\n        curveIntersectionThreshold\n      );\n    };\n    return shape;\n  },\n\n  getminmax: function (curve, d, list) {\n    if (!list) return { min: 0, max: 0 };\n    let min = nMax,\n      max = nMin,\n      t,\n      c;\n    if (list.indexOf(0) === -1) {\n      list = [0].concat(list);\n    }\n    if (list.indexOf(1) === -1) {\n      list.push(1);\n    }\n    for (let i = 0, len = list.length; i < len; i++) {\n      t = list[i];\n      c = curve.get(t);\n      if (c[d] < min) {\n        min = c[d];\n      }\n      if (c[d] > max) {\n        max = c[d];\n      }\n    }\n    return { min: min, mid: (min + max) / 2, max: max, size: max - min };\n  },\n\n  align: function (points, line) {\n    const tx = line.p1.x,\n      ty = line.p1.y,\n      a = -atan2(line.p2.y - ty, line.p2.x - tx),\n      d = function (v) {\n        return {\n          x: (v.x - tx) * cos(a) - (v.y - ty) * sin(a),\n          y: (v.x - tx) * sin(a) + (v.y - ty) * cos(a),\n        };\n      };\n    return points.map(d);\n  },\n\n  roots: function (points, line) {\n    line = line || { p1: { x: 0, y: 0 }, p2: { x: 1, y: 0 } };\n\n    const order = points.length - 1;\n    const aligned = utils.align(points, line);\n    const reduce = function (t) {\n      return 0 <= t && t <= 1;\n    };\n\n    if (order === 2) {\n      const a = aligned[0].y,\n        b = aligned[1].y,\n        c = aligned[2].y,\n        d = a - 2 * b + c;\n      if (d !== 0) {\n        const m1 = -sqrt(b * b - a * c),\n          m2 = -a + b,\n          v1 = -(m1 + m2) / d,\n          v2 = -(-m1 + m2) / d;\n        return [v1, v2].filter(reduce);\n      } else if (b !== c && d === 0) {\n        return [(2 * b - c) / (2 * b - 2 * c)].filter(reduce);\n      }\n      return [];\n    }\n\n    // see http://www.trans4mind.com/personal_development/mathematics/polynomials/cubicAlgebra.htm\n    const pa = aligned[0].y,\n      pb = aligned[1].y,\n      pc = aligned[2].y,\n      pd = aligned[3].y;\n\n    let d = -pa + 3 * pb - 3 * pc + pd,\n      a = 3 * pa - 6 * pb + 3 * pc,\n      b = -3 * pa + 3 * pb,\n      c = pa;\n\n    if (utils.approximately(d, 0)) {\n      // this is not a cubic curve.\n      if (utils.approximately(a, 0)) {\n        // in fact, this is not a quadratic curve either.\n        if (utils.approximately(b, 0)) {\n          // in fact in fact, there are no solutions.\n          return [];\n        }\n        // linear solution:\n        return [-c / b].filter(reduce);\n      }\n      // quadratic solution:\n      const q = sqrt(b * b - 4 * a * c),\n        a2 = 2 * a;\n      return [(q - b) / a2, (-b - q) / a2].filter(reduce);\n    }\n\n    // at this point, we know we need a cubic solution:\n\n    a /= d;\n    b /= d;\n    c /= d;\n\n    const p = (3 * b - a * a) / 3,\n      p3 = p / 3,\n      q = (2 * a * a * a - 9 * a * b + 27 * c) / 27,\n      q2 = q / 2,\n      discriminant = q2 * q2 + p3 * p3 * p3;\n\n    let u1, v1, x1, x2, x3;\n    if (discriminant < 0) {\n      const mp3 = -p / 3,\n        mp33 = mp3 * mp3 * mp3,\n        r = sqrt(mp33),\n        t = -q / (2 * r),\n        cosphi = t < -1 ? -1 : t > 1 ? 1 : t,\n        phi = acos(cosphi),\n        crtr = crt(r),\n        t1 = 2 * crtr;\n      x1 = t1 * cos(phi / 3) - a / 3;\n      x2 = t1 * cos((phi + tau) / 3) - a / 3;\n      x3 = t1 * cos((phi + 2 * tau) / 3) - a / 3;\n      return [x1, x2, x3].filter(reduce);\n    } else if (discriminant === 0) {\n      u1 = q2 < 0 ? crt(-q2) : -crt(q2);\n      x1 = 2 * u1 - a / 3;\n      x2 = -u1 - a / 3;\n      return [x1, x2].filter(reduce);\n    } else {\n      const sd = sqrt(discriminant);\n      u1 = crt(-q2 + sd);\n      v1 = crt(q2 + sd);\n      return [u1 - v1 - a / 3].filter(reduce);\n    }\n  },\n\n  droots: function (p) {\n    // quadratic roots are easy\n    if (p.length === 3) {\n      const a = p[0],\n        b = p[1],\n        c = p[2],\n        d = a - 2 * b + c;\n      if (d !== 0) {\n        const m1 = -sqrt(b * b - a * c),\n          m2 = -a + b,\n          v1 = -(m1 + m2) / d,\n          v2 = -(-m1 + m2) / d;\n        return [v1, v2];\n      } else if (b !== c && d === 0) {\n        return [(2 * b - c) / (2 * (b - c))];\n      }\n      return [];\n    }\n\n    // linear roots are even easier\n    if (p.length === 2) {\n      const a = p[0],\n        b = p[1];\n      if (a !== b) {\n        return [a / (a - b)];\n      }\n      return [];\n    }\n\n    return [];\n  },\n\n  curvature: function (t, d1, d2, _3d, kOnly) {\n    let num,\n      dnm,\n      adk,\n      dk,\n      k = 0,\n      r = 0;\n\n    //\n    // We're using the following formula for curvature:\n    //\n    //              x'y\" - y'x\"\n    //   k(t) = ------------------\n    //           (x'² + y'²)^(3/2)\n    //\n    // from https://en.wikipedia.org/wiki/Radius_of_curvature#Definition\n    //\n    // With it corresponding 3D counterpart:\n    //\n    //          sqrt( (y'z\" - y\"z')² + (z'x\" - z\"x')² + (x'y\" - x\"y')²)\n    //   k(t) = -------------------------------------------------------\n    //                     (x'² + y'² + z'²)^(3/2)\n    //\n\n    const d = utils.compute(t, d1);\n    const dd = utils.compute(t, d2);\n    const qdsum = d.x * d.x + d.y * d.y;\n\n    if (_3d) {\n      num = sqrt(\n        pow(d.y * dd.z - dd.y * d.z, 2) +\n          pow(d.z * dd.x - dd.z * d.x, 2) +\n          pow(d.x * dd.y - dd.x * d.y, 2)\n      );\n      dnm = pow(qdsum + d.z * d.z, 3 / 2);\n    } else {\n      num = d.x * dd.y - d.y * dd.x;\n      dnm = pow(qdsum, 3 / 2);\n    }\n\n    if (num === 0 || dnm === 0) {\n      return { k: 0, r: 0 };\n    }\n\n    k = num / dnm;\n    r = dnm / num;\n\n    // We're also computing the derivative of kappa, because\n    // there is value in knowing the rate of change for the\n    // curvature along the curve. And we're just going to\n    // ballpark it based on an epsilon.\n    if (!kOnly) {\n      // compute k'(t) based on the interval before, and after it,\n      // to at least try to not introduce forward/backward pass bias.\n      const pk = utils.curvature(t - 0.001, d1, d2, _3d, true).k;\n      const nk = utils.curvature(t + 0.001, d1, d2, _3d, true).k;\n      dk = (nk - k + (k - pk)) / 2;\n      adk = (abs(nk - k) + abs(k - pk)) / 2;\n    }\n\n    return { k: k, r: r, dk: dk, adk: adk };\n  },\n\n  inflections: function (points) {\n    if (points.length < 4) return [];\n\n    // FIXME: TODO: add in inflection abstraction for quartic+ curves?\n\n    const p = utils.align(points, { p1: points[0], p2: points.slice(-1)[0] }),\n      a = p[2].x * p[1].y,\n      b = p[3].x * p[1].y,\n      c = p[1].x * p[2].y,\n      d = p[3].x * p[2].y,\n      v1 = 18 * (-3 * a + 2 * b + 3 * c - d),\n      v2 = 18 * (3 * a - b - 3 * c),\n      v3 = 18 * (c - a);\n\n    if (utils.approximately(v1, 0)) {\n      if (!utils.approximately(v2, 0)) {\n        let t = -v3 / v2;\n        if (0 <= t && t <= 1) return [t];\n      }\n      return [];\n    }\n\n    const trm = v2 * v2 - 4 * v1 * v3,\n      sq = Math.sqrt(trm),\n      d2 = 2 * v1;\n\n    if (utils.approximately(d2, 0)) return [];\n\n    return [(sq - v2) / d2, -(v2 + sq) / d2].filter(function (r) {\n      return 0 <= r && r <= 1;\n    });\n  },\n\n  bboxoverlap: function (b1, b2) {\n    const dims = [\"x\", \"y\"],\n      len = dims.length;\n\n    for (let i = 0, dim, l, t, d; i < len; i++) {\n      dim = dims[i];\n      l = b1[dim].mid;\n      t = b2[dim].mid;\n      d = (b1[dim].size + b2[dim].size) / 2;\n      if (abs(l - t) >= d) return false;\n    }\n    return true;\n  },\n\n  expandbox: function (bbox, _bbox) {\n    if (_bbox.x.min < bbox.x.min) {\n      bbox.x.min = _bbox.x.min;\n    }\n    if (_bbox.y.min < bbox.y.min) {\n      bbox.y.min = _bbox.y.min;\n    }\n    if (_bbox.z && _bbox.z.min < bbox.z.min) {\n      bbox.z.min = _bbox.z.min;\n    }\n    if (_bbox.x.max > bbox.x.max) {\n      bbox.x.max = _bbox.x.max;\n    }\n    if (_bbox.y.max > bbox.y.max) {\n      bbox.y.max = _bbox.y.max;\n    }\n    if (_bbox.z && _bbox.z.max > bbox.z.max) {\n      bbox.z.max = _bbox.z.max;\n    }\n    bbox.x.mid = (bbox.x.min + bbox.x.max) / 2;\n    bbox.y.mid = (bbox.y.min + bbox.y.max) / 2;\n    if (bbox.z) {\n      bbox.z.mid = (bbox.z.min + bbox.z.max) / 2;\n    }\n    bbox.x.size = bbox.x.max - bbox.x.min;\n    bbox.y.size = bbox.y.max - bbox.y.min;\n    if (bbox.z) {\n      bbox.z.size = bbox.z.max - bbox.z.min;\n    }\n  },\n\n  pairiteration: function (c1, c2, curveIntersectionThreshold) {\n    const c1b = c1.bbox(),\n      c2b = c2.bbox(),\n      r = 100000,\n      threshold = curveIntersectionThreshold || 0.5;\n\n    if (\n      c1b.x.size + c1b.y.size < threshold &&\n      c2b.x.size + c2b.y.size < threshold\n    ) {\n      return [\n        (((r * (c1._t1 + c1._t2)) / 2) | 0) / r +\n          \"/\" +\n          (((r * (c2._t1 + c2._t2)) / 2) | 0) / r,\n      ];\n    }\n\n    let cc1 = c1.split(0.5),\n      cc2 = c2.split(0.5),\n      pairs = [\n        { left: cc1.left, right: cc2.left },\n        { left: cc1.left, right: cc2.right },\n        { left: cc1.right, right: cc2.right },\n        { left: cc1.right, right: cc2.left },\n      ];\n\n    pairs = pairs.filter(function (pair) {\n      return utils.bboxoverlap(pair.left.bbox(), pair.right.bbox());\n    });\n\n    let results = [];\n\n    if (pairs.length === 0) return results;\n\n    pairs.forEach(function (pair) {\n      results = results.concat(\n        utils.pairiteration(pair.left, pair.right, threshold)\n      );\n    });\n\n    results = results.filter(function (v, i) {\n      return results.indexOf(v) === i;\n    });\n\n    return results;\n  },\n\n  getccenter: function (p1, p2, p3) {\n    const dx1 = p2.x - p1.x,\n      dy1 = p2.y - p1.y,\n      dx2 = p3.x - p2.x,\n      dy2 = p3.y - p2.y,\n      dx1p = dx1 * cos(quart) - dy1 * sin(quart),\n      dy1p = dx1 * sin(quart) + dy1 * cos(quart),\n      dx2p = dx2 * cos(quart) - dy2 * sin(quart),\n      dy2p = dx2 * sin(quart) + dy2 * cos(quart),\n      // chord midpoints\n      mx1 = (p1.x + p2.x) / 2,\n      my1 = (p1.y + p2.y) / 2,\n      mx2 = (p2.x + p3.x) / 2,\n      my2 = (p2.y + p3.y) / 2,\n      // midpoint offsets\n      mx1n = mx1 + dx1p,\n      my1n = my1 + dy1p,\n      mx2n = mx2 + dx2p,\n      my2n = my2 + dy2p,\n      // intersection of these lines:\n      arc = utils.lli8(mx1, my1, mx1n, my1n, mx2, my2, mx2n, my2n),\n      r = utils.dist(arc, p1);\n\n    // arc start/end values, over mid point:\n    let s = atan2(p1.y - arc.y, p1.x - arc.x),\n      m = atan2(p2.y - arc.y, p2.x - arc.x),\n      e = atan2(p3.y - arc.y, p3.x - arc.x),\n      _;\n\n    // determine arc direction (cw/ccw correction)\n    if (s < e) {\n      // if s<m<e, arc(s, e)\n      // if m<s<e, arc(e, s + tau)\n      // if s<e<m, arc(e, s + tau)\n      if (s > m || m > e) {\n        s += tau;\n      }\n      if (s > e) {\n        _ = e;\n        e = s;\n        s = _;\n      }\n    } else {\n      // if e<m<s, arc(e, s)\n      // if m<e<s, arc(s, e + tau)\n      // if e<s<m, arc(s, e + tau)\n      if (e < m && m < s) {\n        _ = e;\n        e = s;\n        s = _;\n      } else {\n        e += tau;\n      }\n    }\n    // assign and done.\n    arc.s = s;\n    arc.e = e;\n    arc.r = r;\n    return arc;\n  },\n\n  numberSort: function (a, b) {\n    return a - b;\n  },\n};\n\nexport { utils };\n","import { utils } from \"./utils.js\";\n\n/**\n * Poly Bezier\n * @param {[type]} curves [description]\n */\nclass PolyBezier {\n  constructor(curves) {\n    this.curves = [];\n    this._3d = false;\n    if (!!curves) {\n      this.curves = curves;\n      this._3d = this.curves[0]._3d;\n    }\n  }\n\n  valueOf() {\n    return this.toString();\n  }\n\n  toString() {\n    return (\n      \"[\" +\n      this.curves\n        .map(function (curve) {\n          return utils.pointsToString(curve.points);\n        })\n        .join(\", \") +\n      \"]\"\n    );\n  }\n\n  addCurve(curve) {\n    this.curves.push(curve);\n    this._3d = this._3d || curve._3d;\n  }\n\n  length() {\n    return this.curves\n      .map(function (v) {\n        return v.length();\n      })\n      .reduce(function (a, b) {\n        return a + b;\n      });\n  }\n\n  curve(idx) {\n    return this.curves[idx];\n  }\n\n  bbox() {\n    const c = this.curves;\n    var bbox = c[0].bbox();\n    for (var i = 1; i < c.length; i++) {\n      utils.expandbox(bbox, c[i].bbox());\n    }\n    return bbox;\n  }\n\n  offset(d) {\n    const offset = [];\n    this.curves.forEach(function (v) {\n      offset.push(...v.offset(d));\n    });\n    return new PolyBezier(offset);\n  }\n}\n\nexport { PolyBezier };\n","/**\n  A javascript Bezier curve library by Pomax.\n\n  Based on http://pomax.github.io/bezierinfo\n\n  This code is MIT licensed.\n**/\n\nimport { utils } from \"./utils.js\";\nimport { PolyBezier } from \"./poly-bezier.js\";\n\n// math-inlining.\nconst { abs, min, max, cos, sin, acos, sqrt } = Math;\nconst pi = Math.PI;\n// a zero coordinate, which is surprisingly useful\nconst ZERO = { x: 0, y: 0, z: 0 };\n\n/**\n * Bezier curve constructor.\n *\n * ...docs pending...\n */\nclass Bezier {\n  constructor(coords) {\n    let args =\n      coords && coords.forEach ? coords : Array.from(arguments).slice();\n    let coordlen = false;\n\n    if (typeof args[0] === \"object\") {\n      coordlen = args.length;\n      const newargs = [];\n      args.forEach(function (point) {\n        [\"x\", \"y\", \"z\"].forEach(function (d) {\n          if (typeof point[d] !== \"undefined\") {\n            newargs.push(point[d]);\n          }\n        });\n      });\n      args = newargs;\n    }\n\n    let higher = false;\n    const len = args.length;\n\n    if (coordlen) {\n      if (coordlen > 4) {\n        if (arguments.length !== 1) {\n          throw new Error(\n            \"Only new Bezier(point[]) is accepted for 4th and higher order curves\"\n          );\n        }\n        higher = true;\n      }\n    } else {\n      if (len !== 6 && len !== 8 && len !== 9 && len !== 12) {\n        if (arguments.length !== 1) {\n          throw new Error(\n            \"Only new Bezier(point[]) is accepted for 4th and higher order curves\"\n          );\n        }\n      }\n    }\n\n    const _3d = (this._3d =\n      (!higher && (len === 9 || len === 12)) ||\n      (coords && coords[0] && typeof coords[0].z !== \"undefined\"));\n\n    const points = (this.points = []);\n    for (let idx = 0, step = _3d ? 3 : 2; idx < len; idx += step) {\n      var point = {\n        x: args[idx],\n        y: args[idx + 1],\n      };\n      if (_3d) {\n        point.z = args[idx + 2];\n      }\n      points.push(point);\n    }\n    const order = (this.order = points.length - 1);\n\n    const dims = (this.dims = [\"x\", \"y\"]);\n    if (_3d) dims.push(\"z\");\n    this.dimlen = dims.length;\n\n    const aligned = utils.align(points, { p1: points[0], p2: points[order] });\n    this._linear = !aligned.some((p) => abs(p.y) > 0.0001);\n\n    this._lut = [];\n\n    this._t1 = 0;\n    this._t2 = 1;\n    this.update();\n  }\n\n  static quadraticFromPoints(p1, p2, p3, t) {\n    if (typeof t === \"undefined\") {\n      t = 0.5;\n    }\n    // shortcuts, although they're really dumb\n    if (t === 0) {\n      return new Bezier(p2, p2, p3);\n    }\n    if (t === 1) {\n      return new Bezier(p1, p2, p2);\n    }\n    // real fitting.\n    const abc = Bezier.getABC(2, p1, p2, p3, t);\n    return new Bezier(p1, abc.A, p3);\n  }\n\n  static cubicFromPoints(S, B, E, t, d1) {\n    if (typeof t === \"undefined\") {\n      t = 0.5;\n    }\n    const abc = Bezier.getABC(3, S, B, E, t);\n    if (typeof d1 === \"undefined\") {\n      d1 = utils.dist(B, abc.C);\n    }\n    const d2 = (d1 * (1 - t)) / t;\n\n    const selen = utils.dist(S, E),\n      lx = (E.x - S.x) / selen,\n      ly = (E.y - S.y) / selen,\n      bx1 = d1 * lx,\n      by1 = d1 * ly,\n      bx2 = d2 * lx,\n      by2 = d2 * ly;\n    // derivation of new hull coordinates\n    const e1 = { x: B.x - bx1, y: B.y - by1 },\n      e2 = { x: B.x + bx2, y: B.y + by2 },\n      A = abc.A,\n      v1 = { x: A.x + (e1.x - A.x) / (1 - t), y: A.y + (e1.y - A.y) / (1 - t) },\n      v2 = { x: A.x + (e2.x - A.x) / t, y: A.y + (e2.y - A.y) / t },\n      nc1 = { x: S.x + (v1.x - S.x) / t, y: S.y + (v1.y - S.y) / t },\n      nc2 = {\n        x: E.x + (v2.x - E.x) / (1 - t),\n        y: E.y + (v2.y - E.y) / (1 - t),\n      };\n    // ...done\n    return new Bezier(S, nc1, nc2, E);\n  }\n\n  static getUtils() {\n    return utils;\n  }\n\n  getUtils() {\n    return Bezier.getUtils();\n  }\n\n  static get PolyBezier() {\n    return PolyBezier;\n  }\n\n  valueOf() {\n    return this.toString();\n  }\n\n  toString() {\n    return utils.pointsToString(this.points);\n  }\n\n  toSVG() {\n    if (this._3d) return false;\n    const p = this.points,\n      x = p[0].x,\n      y = p[0].y,\n      s = [\"M\", x, y, this.order === 2 ? \"Q\" : \"C\"];\n    for (let i = 1, last = p.length; i < last; i++) {\n      s.push(p[i].x);\n      s.push(p[i].y);\n    }\n    return s.join(\" \");\n  }\n\n  setRatios(ratios) {\n    if (ratios.length !== this.points.length) {\n      throw new Error(\"incorrect number of ratio values\");\n    }\n    this.ratios = ratios;\n    this._lut = []; //  invalidate any precomputed LUT\n  }\n\n  verify() {\n    const print = this.coordDigest();\n    if (print !== this._print) {\n      this._print = print;\n      this.update();\n    }\n  }\n\n  coordDigest() {\n    return this.points\n      .map(function (c, pos) {\n        return \"\" + pos + c.x + c.y + (c.z ? c.z : 0);\n      })\n      .join(\"\");\n  }\n\n  update() {\n    // invalidate any precomputed LUT\n    this._lut = [];\n    this.dpoints = utils.derive(this.points, this._3d);\n    this.computedirection();\n  }\n\n  computedirection() {\n    const points = this.points;\n    const angle = utils.angle(points[0], points[this.order], points[1]);\n    this.clockwise = angle > 0;\n  }\n\n  length() {\n    return utils.length(this.derivative.bind(this));\n  }\n\n  static getABC(order = 2, S, B, E, t = 0.5) {\n    const u = utils.projectionratio(t, order),\n      um = 1 - u,\n      C = {\n        x: u * S.x + um * E.x,\n        y: u * S.y + um * E.y,\n      },\n      s = utils.abcratio(t, order),\n      A = {\n        x: B.x + (B.x - C.x) / s,\n        y: B.y + (B.y - C.y) / s,\n      };\n    return { A, B, C, S, E };\n  }\n\n  getABC(t, B) {\n    B = B || this.get(t);\n    let S = this.points[0];\n    let E = this.points[this.order];\n    return Bezier.getABC(this.order, S, B, E, t);\n  }\n\n  getLUT(steps) {\n    this.verify();\n    steps = steps || 100;\n    if (this._lut.length === steps) {\n      return this._lut;\n    }\n    this._lut = [];\n    // We want a range from 0 to 1 inclusive, so\n    // we decrement and then use <= rather than <:\n    steps--;\n    for (let i = 0, p, t; i < steps; i++) {\n      t = i / (steps - 1);\n      p = this.compute(t);\n      p.t = t;\n      this._lut.push(p);\n    }\n    return this._lut;\n  }\n\n  on(point, error) {\n    error = error || 5;\n    const lut = this.getLUT(),\n      hits = [];\n    for (let i = 0, c, t = 0; i < lut.length; i++) {\n      c = lut[i];\n      if (utils.dist(c, point) < error) {\n        hits.push(c);\n        t += i / lut.length;\n      }\n    }\n    if (!hits.length) return false;\n    return (t /= hits.length);\n  }\n\n  project(point) {\n    // step 1: coarse check\n    const LUT = this.getLUT(),\n      l = LUT.length - 1,\n      closest = utils.closest(LUT, point),\n      mpos = closest.mpos,\n      t1 = (mpos - 1) / l,\n      t2 = (mpos + 1) / l,\n      step = 0.1 / l;\n\n    // step 2: fine check\n    let mdist = closest.mdist,\n      t = t1,\n      ft = t,\n      p;\n    mdist += 1;\n    for (let d; t < t2 + step; t += step) {\n      p = this.compute(t);\n      d = utils.dist(point, p);\n      if (d < mdist) {\n        mdist = d;\n        ft = t;\n      }\n    }\n    ft = ft < 0 ? 0 : ft > 1 ? 1 : ft;\n    p = this.compute(ft);\n    p.t = ft;\n    p.d = mdist;\n    return p;\n  }\n\n  get(t) {\n    return this.compute(t);\n  }\n\n  point(idx) {\n    return this.points[idx];\n  }\n\n  compute(t) {\n    if (this.ratios) {\n      return utils.computeWithRatios(t, this.points, this.ratios, this._3d);\n    }\n    return utils.compute(t, this.points, this._3d, this.ratios);\n  }\n\n  raise() {\n    const p = this.points,\n      np = [p[0]],\n      k = p.length;\n    for (let i = 1, pi, pim; i < k; i++) {\n      pi = p[i];\n      pim = p[i - 1];\n      np[i] = {\n        x: ((k - i) / k) * pi.x + (i / k) * pim.x,\n        y: ((k - i) / k) * pi.y + (i / k) * pim.y,\n      };\n    }\n    np[k] = p[k - 1];\n    return new Bezier(np);\n  }\n\n  derivative(t) {\n    return utils.compute(t, this.dpoints[0], this._3d);\n  }\n\n  dderivative(t) {\n    return utils.compute(t, this.dpoints[1], this._3d);\n  }\n\n  align() {\n    let p = this.points;\n    return new Bezier(utils.align(p, { p1: p[0], p2: p[p.length - 1] }));\n  }\n\n  curvature(t) {\n    return utils.curvature(t, this.dpoints[0], this.dpoints[1], this._3d);\n  }\n\n  inflections() {\n    return utils.inflections(this.points);\n  }\n\n  normal(t) {\n    return this._3d ? this.__normal3(t) : this.__normal2(t);\n  }\n\n  __normal2(t) {\n    const d = this.derivative(t);\n    const q = sqrt(d.x * d.x + d.y * d.y);\n    return { x: -d.y / q, y: d.x / q };\n  }\n\n  __normal3(t) {\n    // see http://stackoverflow.com/questions/25453159\n    const r1 = this.derivative(t),\n      r2 = this.derivative(t + 0.01),\n      q1 = sqrt(r1.x * r1.x + r1.y * r1.y + r1.z * r1.z),\n      q2 = sqrt(r2.x * r2.x + r2.y * r2.y + r2.z * r2.z);\n    r1.x /= q1;\n    r1.y /= q1;\n    r1.z /= q1;\n    r2.x /= q2;\n    r2.y /= q2;\n    r2.z /= q2;\n    // cross product\n    const c = {\n      x: r2.y * r1.z - r2.z * r1.y,\n      y: r2.z * r1.x - r2.x * r1.z,\n      z: r2.x * r1.y - r2.y * r1.x,\n    };\n    const m = sqrt(c.x * c.x + c.y * c.y + c.z * c.z);\n    c.x /= m;\n    c.y /= m;\n    c.z /= m;\n    // rotation matrix\n    const R = [\n      c.x * c.x,\n      c.x * c.y - c.z,\n      c.x * c.z + c.y,\n      c.x * c.y + c.z,\n      c.y * c.y,\n      c.y * c.z - c.x,\n      c.x * c.z - c.y,\n      c.y * c.z + c.x,\n      c.z * c.z,\n    ];\n    // normal vector:\n    const n = {\n      x: R[0] * r1.x + R[1] * r1.y + R[2] * r1.z,\n      y: R[3] * r1.x + R[4] * r1.y + R[5] * r1.z,\n      z: R[6] * r1.x + R[7] * r1.y + R[8] * r1.z,\n    };\n    return n;\n  }\n\n  hull(t) {\n    let p = this.points,\n      _p = [],\n      q = [],\n      idx = 0;\n    q[idx++] = p[0];\n    q[idx++] = p[1];\n    q[idx++] = p[2];\n    if (this.order === 3) {\n      q[idx++] = p[3];\n    }\n    // we lerp between all points at each iteration, until we have 1 point left.\n    while (p.length > 1) {\n      _p = [];\n      for (let i = 0, pt, l = p.length - 1; i < l; i++) {\n        pt = utils.lerp(t, p[i], p[i + 1]);\n        q[idx++] = pt;\n        _p.push(pt);\n      }\n      p = _p;\n    }\n    return q;\n  }\n\n  split(t1, t2) {\n    // shortcuts\n    if (t1 === 0 && !!t2) {\n      return this.split(t2).left;\n    }\n    if (t2 === 1) {\n      return this.split(t1).right;\n    }\n\n    // no shortcut: use \"de Casteljau\" iteration.\n    const q = this.hull(t1);\n    const result = {\n      left:\n        this.order === 2\n          ? new Bezier([q[0], q[3], q[5]])\n          : new Bezier([q[0], q[4], q[7], q[9]]),\n      right:\n        this.order === 2\n          ? new Bezier([q[5], q[4], q[2]])\n          : new Bezier([q[9], q[8], q[6], q[3]]),\n      span: q,\n    };\n\n    // make sure we bind _t1/_t2 information!\n    result.left._t1 = utils.map(0, 0, 1, this._t1, this._t2);\n    result.left._t2 = utils.map(t1, 0, 1, this._t1, this._t2);\n    result.right._t1 = utils.map(t1, 0, 1, this._t1, this._t2);\n    result.right._t2 = utils.map(1, 0, 1, this._t1, this._t2);\n\n    // if we have no t2, we're done\n    if (!t2) {\n      return result;\n    }\n\n    // if we have a t2, split again:\n    t2 = utils.map(t2, t1, 1, 0, 1);\n    return result.right.split(t2).left;\n  }\n\n  extrema() {\n    const result = {};\n    let roots = [];\n\n    this.dims.forEach(\n      function (dim) {\n        let mfn = function (v) {\n          return v[dim];\n        };\n        let p = this.dpoints[0].map(mfn);\n        result[dim] = utils.droots(p);\n        if (this.order === 3) {\n          p = this.dpoints[1].map(mfn);\n          result[dim] = result[dim].concat(utils.droots(p));\n        }\n        result[dim] = result[dim].filter(function (t) {\n          return t >= 0 && t <= 1;\n        });\n        roots = roots.concat(result[dim].sort(utils.numberSort));\n      }.bind(this)\n    );\n\n    result.values = roots.sort(utils.numberSort).filter(function (v, idx) {\n      return roots.indexOf(v) === idx;\n    });\n\n    return result;\n  }\n\n  bbox() {\n    const extrema = this.extrema(),\n      result = {};\n    this.dims.forEach(\n      function (d) {\n        result[d] = utils.getminmax(this, d, extrema[d]);\n      }.bind(this)\n    );\n    return result;\n  }\n\n  overlaps(curve) {\n    const lbbox = this.bbox(),\n      tbbox = curve.bbox();\n    return utils.bboxoverlap(lbbox, tbbox);\n  }\n\n  offset(t, d) {\n    if (typeof d !== \"undefined\") {\n      const c = this.get(t),\n        n = this.normal(t);\n      const ret = {\n        c: c,\n        n: n,\n        x: c.x + n.x * d,\n        y: c.y + n.y * d,\n      };\n      if (this._3d) {\n        ret.z = c.z + n.z * d;\n      }\n      return ret;\n    }\n    if (this._linear) {\n      const nv = this.normal(0),\n        coords = this.points.map(function (p) {\n          const ret = {\n            x: p.x + t * nv.x,\n            y: p.y + t * nv.y,\n          };\n          if (p.z && nv.z) {\n            ret.z = p.z + t * nv.z;\n          }\n          return ret;\n        });\n      return [new Bezier(coords)];\n    }\n    return this.reduce().map(function (s) {\n      if (s._linear) {\n        return s.offset(t)[0];\n      }\n      return s.scale(t);\n    });\n  }\n\n  simple() {\n    if (this.order === 3) {\n      const a1 = utils.angle(this.points[0], this.points[3], this.points[1]);\n      const a2 = utils.angle(this.points[0], this.points[3], this.points[2]);\n      if ((a1 > 0 && a2 < 0) || (a1 < 0 && a2 > 0)) return false;\n    }\n    const n1 = this.normal(0);\n    const n2 = this.normal(1);\n    let s = n1.x * n2.x + n1.y * n2.y;\n    if (this._3d) {\n      s += n1.z * n2.z;\n    }\n    return abs(acos(s)) < pi / 3;\n  }\n\n  reduce() {\n    // TODO: examine these var types in more detail...\n    let i,\n      t1 = 0,\n      t2 = 0,\n      step = 0.01,\n      segment,\n      pass1 = [],\n      pass2 = [];\n    // first pass: split on extrema\n    let extrema = this.extrema().values;\n    if (extrema.indexOf(0) === -1) {\n      extrema = [0].concat(extrema);\n    }\n    if (extrema.indexOf(1) === -1) {\n      extrema.push(1);\n    }\n\n    for (t1 = extrema[0], i = 1; i < extrema.length; i++) {\n      t2 = extrema[i];\n      segment = this.split(t1, t2);\n      segment._t1 = t1;\n      segment._t2 = t2;\n      pass1.push(segment);\n      t1 = t2;\n    }\n\n    // second pass: further reduce these segments to simple segments\n    pass1.forEach(function (p1) {\n      t1 = 0;\n      t2 = 0;\n      while (t2 <= 1) {\n        for (t2 = t1 + step; t2 <= 1 + step; t2 += step) {\n          segment = p1.split(t1, t2);\n          if (!segment.simple()) {\n            t2 -= step;\n            if (abs(t1 - t2) < step) {\n              // we can never form a reduction\n              return [];\n            }\n            segment = p1.split(t1, t2);\n            segment._t1 = utils.map(t1, 0, 1, p1._t1, p1._t2);\n            segment._t2 = utils.map(t2, 0, 1, p1._t1, p1._t2);\n            pass2.push(segment);\n            t1 = t2;\n            break;\n          }\n        }\n      }\n      if (t1 < 1) {\n        segment = p1.split(t1, 1);\n        segment._t1 = utils.map(t1, 0, 1, p1._t1, p1._t2);\n        segment._t2 = p1._t2;\n        pass2.push(segment);\n      }\n    });\n    return pass2;\n  }\n\n  scale(d) {\n    const order = this.order;\n    let distanceFn = false;\n    if (typeof d === \"function\") {\n      distanceFn = d;\n    }\n    if (distanceFn && order === 2) {\n      return this.raise().scale(distanceFn);\n    }\n\n    // TODO: add special handling for degenerate (=linear) curves.\n    const clockwise = this.clockwise;\n    const r1 = distanceFn ? distanceFn(0) : d;\n    const r2 = distanceFn ? distanceFn(1) : d;\n    const v = [this.offset(0, 10), this.offset(1, 10)];\n    const points = this.points;\n    const np = [];\n    const o = utils.lli4(v[0], v[0].c, v[1], v[1].c);\n\n    if (!o) {\n      throw new Error(\"cannot scale this curve. Try reducing it first.\");\n    }\n    // move all points by distance 'd' wrt the origin 'o'\n\n    // move end points by fixed distance along normal.\n    [0, 1].forEach(function (t) {\n      const p = (np[t * order] = utils.copy(points[t * order]));\n      p.x += (t ? r2 : r1) * v[t].n.x;\n      p.y += (t ? r2 : r1) * v[t].n.y;\n    });\n\n    if (!distanceFn) {\n      // move control points to lie on the intersection of the offset\n      // derivative vector, and the origin-through-control vector\n      [0, 1].forEach((t) => {\n        if (order === 2 && !!t) return;\n        const p = np[t * order];\n        const d = this.derivative(t);\n        const p2 = { x: p.x + d.x, y: p.y + d.y };\n        np[t + 1] = utils.lli4(p, p2, o, points[t + 1]);\n      });\n      return new Bezier(np);\n    }\n\n    // move control points by \"however much necessary to\n    // ensure the correct tangent to endpoint\".\n    [0, 1].forEach(function (t) {\n      if (order === 2 && !!t) return;\n      var p = points[t + 1];\n      var ov = {\n        x: p.x - o.x,\n        y: p.y - o.y,\n      };\n      var rc = distanceFn ? distanceFn((t + 1) / order) : d;\n      if (distanceFn && !clockwise) rc = -rc;\n      var m = sqrt(ov.x * ov.x + ov.y * ov.y);\n      ov.x /= m;\n      ov.y /= m;\n      np[t + 1] = {\n        x: p.x + rc * ov.x,\n        y: p.y + rc * ov.y,\n      };\n    });\n    return new Bezier(np);\n  }\n\n  outline(d1, d2, d3, d4) {\n    d2 = typeof d2 === \"undefined\" ? d1 : d2;\n    const reduced = this.reduce(),\n      len = reduced.length,\n      fcurves = [];\n\n    let bcurves = [],\n      p,\n      alen = 0,\n      tlen = this.length();\n\n    const graduated = typeof d3 !== \"undefined\" && typeof d4 !== \"undefined\";\n\n    function linearDistanceFunction(s, e, tlen, alen, slen) {\n      return function (v) {\n        const f1 = alen / tlen,\n          f2 = (alen + slen) / tlen,\n          d = e - s;\n        return utils.map(v, 0, 1, s + f1 * d, s + f2 * d);\n      };\n    }\n\n    // form curve oulines\n    reduced.forEach(function (segment) {\n      const slen = segment.length();\n      if (graduated) {\n        fcurves.push(\n          segment.scale(linearDistanceFunction(d1, d3, tlen, alen, slen))\n        );\n        bcurves.push(\n          segment.scale(linearDistanceFunction(-d2, -d4, tlen, alen, slen))\n        );\n      } else {\n        fcurves.push(segment.scale(d1));\n        bcurves.push(segment.scale(-d2));\n      }\n      alen += slen;\n    });\n\n    // reverse the \"return\" outline\n    bcurves = bcurves\n      .map(function (s) {\n        p = s.points;\n        if (p[3]) {\n          s.points = [p[3], p[2], p[1], p[0]];\n        } else {\n          s.points = [p[2], p[1], p[0]];\n        }\n        return s;\n      })\n      .reverse();\n\n    // form the endcaps as lines\n    const fs = fcurves[0].points[0],\n      fe = fcurves[len - 1].points[fcurves[len - 1].points.length - 1],\n      bs = bcurves[len - 1].points[bcurves[len - 1].points.length - 1],\n      be = bcurves[0].points[0],\n      ls = utils.makeline(bs, fs),\n      le = utils.makeline(fe, be),\n      segments = [ls].concat(fcurves).concat([le]).concat(bcurves),\n      slen = segments.length;\n\n    return new PolyBezier(segments);\n  }\n\n  outlineshapes(d1, d2, curveIntersectionThreshold) {\n    d2 = d2 || d1;\n    const outline = this.outline(d1, d2).curves;\n    const shapes = [];\n    for (let i = 1, len = outline.length; i < len / 2; i++) {\n      const shape = utils.makeshape(\n        outline[i],\n        outline[len - i],\n        curveIntersectionThreshold\n      );\n      shape.startcap.virtual = i > 1;\n      shape.endcap.virtual = i < len / 2 - 1;\n      shapes.push(shape);\n    }\n    return shapes;\n  }\n\n  intersects(curve, curveIntersectionThreshold) {\n    if (!curve) return this.selfintersects(curveIntersectionThreshold);\n    if (curve.p1 && curve.p2) {\n      return this.lineIntersects(curve);\n    }\n    if (curve instanceof Bezier) {\n      curve = curve.reduce();\n    }\n    return this.curveintersects(\n      this.reduce(),\n      curve,\n      curveIntersectionThreshold\n    );\n  }\n\n  lineIntersects(line) {\n    const mx = min(line.p1.x, line.p2.x),\n      my = min(line.p1.y, line.p2.y),\n      MX = max(line.p1.x, line.p2.x),\n      MY = max(line.p1.y, line.p2.y);\n    return utils.roots(this.points, line).filter((t) => {\n      var p = this.get(t);\n      return utils.between(p.x, mx, MX) && utils.between(p.y, my, MY);\n    });\n  }\n\n  selfintersects(curveIntersectionThreshold) {\n    // \"simple\" curves cannot intersect with their direct\n    // neighbour, so for each segment X we check whether\n    // it intersects [0:x-2][x+2:last].\n\n    const reduced = this.reduce(),\n      len = reduced.length - 2,\n      results = [];\n\n    for (let i = 0, result, left, right; i < len; i++) {\n      left = reduced.slice(i, i + 1);\n      right = reduced.slice(i + 2);\n      result = this.curveintersects(left, right, curveIntersectionThreshold);\n      results.push(...result);\n    }\n    return results;\n  }\n\n  curveintersects(c1, c2, curveIntersectionThreshold) {\n    const pairs = [];\n    // step 1: pair off any overlapping segments\n    c1.forEach(function (l) {\n      c2.forEach(function (r) {\n        if (l.overlaps(r)) {\n          pairs.push({ left: l, right: r });\n        }\n      });\n    });\n    // step 2: for each pairing, run through the convergence algorithm.\n    let intersections = [];\n    pairs.forEach(function (pair) {\n      const result = utils.pairiteration(\n        pair.left,\n        pair.right,\n        curveIntersectionThreshold\n      );\n      if (result.length > 0) {\n        intersections = intersections.concat(result);\n      }\n    });\n    return intersections;\n  }\n\n  arcs(errorThreshold) {\n    errorThreshold = errorThreshold || 0.5;\n    return this._iterate(errorThreshold, []);\n  }\n\n  _error(pc, np1, s, e) {\n    const q = (e - s) / 4,\n      c1 = this.get(s + q),\n      c2 = this.get(e - q),\n      ref = utils.dist(pc, np1),\n      d1 = utils.dist(pc, c1),\n      d2 = utils.dist(pc, c2);\n    return abs(d1 - ref) + abs(d2 - ref);\n  }\n\n  _iterate(errorThreshold, circles) {\n    let t_s = 0,\n      t_e = 1,\n      safety;\n    // we do a binary search to find the \"good `t` closest to no-longer-good\"\n    do {\n      safety = 0;\n\n      // step 1: start with the maximum possible arc\n      t_e = 1;\n\n      // points:\n      let np1 = this.get(t_s),\n        np2,\n        np3,\n        arc,\n        prev_arc;\n\n      // booleans:\n      let curr_good = false,\n        prev_good = false,\n        done;\n\n      // numbers:\n      let t_m = t_e,\n        prev_e = 1,\n        step = 0;\n\n      // step 2: find the best possible arc\n      do {\n        prev_good = curr_good;\n        prev_arc = arc;\n        t_m = (t_s + t_e) / 2;\n        step++;\n\n        np2 = this.get(t_m);\n        np3 = this.get(t_e);\n\n        arc = utils.getccenter(np1, np2, np3);\n\n        //also save the t values\n        arc.interval = {\n          start: t_s,\n          end: t_e,\n        };\n\n        let error = this._error(arc, np1, t_s, t_e);\n        curr_good = error <= errorThreshold;\n\n        done = prev_good && !curr_good;\n        if (!done) prev_e = t_e;\n\n        // this arc is fine: we can move 'e' up to see if we can find a wider arc\n        if (curr_good) {\n          // if e is already at max, then we're done for this arc.\n          if (t_e >= 1) {\n            // make sure we cap at t=1\n            arc.interval.end = prev_e = 1;\n            prev_arc = arc;\n            // if we capped the arc segment to t=1 we also need to make sure that\n            // the arc's end angle is correct with respect to the bezier end point.\n            if (t_e > 1) {\n              let d = {\n                x: arc.x + arc.r * cos(arc.e),\n                y: arc.y + arc.r * sin(arc.e),\n              };\n              arc.e += utils.angle({ x: arc.x, y: arc.y }, d, this.get(1));\n            }\n            break;\n          }\n          // if not, move it up by half the iteration distance\n          t_e = t_e + (t_e - t_s) / 2;\n        } else {\n          // this is a bad arc: we need to move 'e' down to find a good arc\n          t_e = t_m;\n        }\n      } while (!done && safety++ < 100);\n\n      if (safety >= 100) {\n        break;\n      }\n\n      // console.log(\"L835: [F] arc found\", t_s, prev_e, prev_arc.x, prev_arc.y, prev_arc.s, prev_arc.e);\n\n      prev_arc = prev_arc ? prev_arc : arc;\n      circles.push(prev_arc);\n      t_s = prev_e;\n    } while (t_e < 1);\n    return circles;\n  }\n}\n\nexport { Bezier };\n"],"names":["module","exports","Collection","Events","Instance","Log","Model","Module","Singleton","Spine","association","createObject","makeArray","moduleKeywords","singularize","underscore","slice","indexOf","item","i","l","this","length","extend","child","parent","key","hasProp","call","ctor","constructor","prototype","__super__","hasOwnProperty","on","ev","callback","base","evs","j","len","name","split","_callbacks","push","one","handler","off","apply","arguments","trigger","args","list","ref","shift","listenTo","obj","listeningTo","listenToOnce","listeningToOnce","idx","lt","splice","stopListening","events","e","evts","k","len1","len2","len3","m","n","ref1","ref2","len4","p","results","join","trim","bind","unbind","trace","logPrefix","log","unshift","console","init","include","value","Error","included","extended","proxy","func","_this","superClass","atts","uuid","cid","id","uid","load","records","irecords","attributes","configure","className","deleteAll","toString","find","notFound","clone","findAll","ids","exists","Boolean","addRecord","record","root","refresh","values","options","result","clear","fromJSON","Array","isArray","sort","cloneArray","select","findByAttribute","findAllByAttribute","each","all","begin","end","first","last","count","destroyAll","destroy","update","updateAttributes","create","save","change","callbackOrParams","concat","fetch","toJSON","beforeFromJSON","objects","JSON","parse","comparator","array","idCounter","prefix","isNew","isValid","validate","eql","rec","error","stripCloneAttrs","updateAttribute","changeID","remove","destroyed","dup","newRecord","reload","original","stringify","Object","o","Func","version","sub","instances","statics","Result","setup","Class","model","associated","cb","fkey","add","str","replace","toLowerCase","Ctor","hasMany","belongsTo","hasOne","deselectCurrent","clipboardToIE11Formatting","text","debug","message","reselectPrevious","range","selection","mark","success","document","createRange","getSelection","createElement","textContent","style","position","top","clip","whiteSpace","webkitUserSelect","MozUserSelect","msUserSelect","userSelect","addEventListener","stopPropagation","format","preventDefault","clipboardData","warn","window","clearData","setData","onCopy","body","appendChild","selectNodeContents","addRange","execCommand","err","copyKey","test","navigator","userAgent","prompt","removeRange","removeAllRanges","removeChild","addBusinessDays","dirtyDate","dirtyAmount","requiredArgs","date","toDate","startedOnWeekend","isWeekend","amount","toInteger","isNaN","Date","NaN","hours","getHours","sign","fullWeeks","setDate","getDate","restDays","Math","abs","getDay","isSaturday","isSunday","setHours","duration","years","months","weeks","days","minutes","seconds","dateWithMonths","dateWithDays","msToAdd","getTime","eachDayOfInterval","dirtyInterval","interval","startDate","start","endTime","RangeError","dates","currentDate","step","Number","isSameMonth","dirtyDateLeft","dirtyDateRight","dateLeft","dateRight","getFullYear","getMonth","isSameWeek","dirtyOptions","dateLeftStartOfWeek","dateRightStartOfWeek","day","isWithinInterval","time","startTime","lastDayOfMonth","month","setFullYear","lastDayOfWeek","locale","localeWeekStartsOn","weekStartsOn","defaultWeekStartsOn","diff","setMonth","dirtyMonth","year","dateWithDesiredMonth","daysInMonth","monthIndex","getDaysInMonth","min","set","setMinutes","setSeconds","milliseconds","setMilliseconds","startOfMonth","startOfWeek","startOfYear","cleanDate","subYears","addMonths","addYears","token","singleMatcher","RegExp","multiMatcher","decodeComponents","components","decodeURIComponent","left","right","decode","input","tokens","match","encodedURI","TypeError","replaceMap","exec","entries","keys","customDecodeURIComponent","predicate","ret","isArr","val","exportName","undefined","assign","VENDOR_PREFIXES","TEST_ELEMENT","TYPE_FUNCTION","round","now","setTimeoutContext","fn","timeout","context","setTimeout","bindFn","invokeArrayArg","arg","iterator","forEach","deprecate","method","deprecationMessage","stack","target","output","index","source","nextKey","dest","src","merge","inherit","properties","childP","baseP","_super","boolOrFn","ifUndefined","val1","val2","addEventListeners","types","splitStr","type","removeEventListeners","removeEventListener","hasParent","node","parentNode","inStr","inArray","findByKey","toArray","uniqueArray","a","b","prefixed","property","prop","camelProp","toUpperCase","_uniqueId","getWindowForElement","element","doc","ownerDocument","defaultView","parentWindow","SUPPORT_TOUCH","SUPPORT_POINTER_EVENTS","SUPPORT_ONLY_TOUCH","INPUT_TYPE_TOUCH","INPUT_TYPE_MOUSE","COMPUTE_INTERVAL","INPUT_START","INPUT_END","INPUT_CANCEL","DIRECTION_NONE","DIRECTION_LEFT","DIRECTION_RIGHT","DIRECTION_UP","DIRECTION_DOWN","DIRECTION_HORIZONTAL","DIRECTION_VERTICAL","DIRECTION_ALL","PROPS_XY","PROPS_CLIENT_XY","Input","manager","self","inputTarget","domHandler","enable","inputHandler","eventType","pointersLen","pointers","changedPointersLen","changedPointers","isFirst","isFinal","session","pointersLength","firstInput","simpleCloneInputData","firstMultiple","offsetCenter","center","getCenter","timeStamp","deltaTime","angle","getAngle","distance","getDistance","offset","offsetDelta","prevDelta","prevInput","x","deltaX","y","deltaY","computeDeltaXY","offsetDirection","getDirection","overallVelocity","getVelocity","overallVelocityX","overallVelocityY","scale","rotation","getRotation","maxPointers","velocity","velocityX","velocityY","direction","lastInterval","v","computeIntervalInputData","srcEvent","computeInputData","emit","recognize","clientX","clientY","p1","p2","props","sqrt","atan2","PI","evEl","evTarget","evWin","MOUSE_INPUT_MAP","mousedown","mousemove","mouseup","MOUSE_ELEMENT_EVENTS","MOUSE_WINDOW_EVENTS","MouseInput","pressed","button","which","pointerType","POINTER_INPUT_MAP","pointerdown","pointermove","pointerup","pointercancel","pointerout","IE10_POINTER_TYPE_ENUM","POINTER_ELEMENT_EVENTS","POINTER_WINDOW_EVENTS","PointerEventInput","store","pointerEvents","MSPointerEvent","PointerEvent","removePointer","eventTypeNormalized","isTouch","storeIndex","pointerId","SINGLE_TOUCH_INPUT_MAP","touchstart","touchmove","touchend","touchcancel","SingleTouchInput","started","normalizeSingleTouches","touches","changed","changedTouches","TOUCH_INPUT_MAP","TOUCH_TARGET_EVENTS","TouchInput","targetIds","getTouches","allTouches","identifier","targetTouches","changedTargetTouches","filter","touch","DEDUP_TIMEOUT","TouchMouseInput","mouse","primaryTouch","lastTouches","recordTouches","eventData","setLastTouch","lastTouch","lts","isSyntheticEvent","t","dx","dy","inputEvent","inputData","isMouse","sourceCapabilities","firesTouchEvents","PREFIXED_TOUCH_ACTION","NATIVE_TOUCH_ACTION","TOUCH_ACTION_COMPUTE","TOUCH_ACTION_AUTO","TOUCH_ACTION_MANIPULATION","TOUCH_ACTION_NONE","TOUCH_ACTION_PAN_X","TOUCH_ACTION_PAN_Y","TOUCH_ACTION_MAP","touchMap","cssSupports","CSS","supports","getTouchActionProps","TouchAction","compute","actions","touchAction","recognizers","recognizer","getTouchAction","hasPanX","hasPanY","cleanTouchActions","preventDefaults","prevented","hasNone","isTapPointer","isTapMovement","isTapTouchTime","preventSrc","STATE_POSSIBLE","STATE_FAILED","Recognizer","defaults","state","simultaneous","requireFail","stateStr","directionStr","getRecognizerByNameIfManager","otherRecognizer","get","AttrRecognizer","PanRecognizer","pX","pY","PinchRecognizer","PressRecognizer","_timer","_input","RotateRecognizer","SwipeRecognizer","TapRecognizer","pTime","pCenter","Hammer","preset","Manager","recognizeWith","dropRecognizeWith","requireFailure","dropRequireFailure","hasRequireFailures","canRecognizeWith","event","additionalEvent","tryEmit","canEmit","inputDataClone","reset","process","attrTest","optionPointers","isRecognized","threshold","directionTest","hasMoved","inOut","validPointers","validMovement","validTime","clearTimeout","taps","posThreshold","validTouchTime","failTimeout","validInterval","validMultiTap","tapCount","VERSION","domEvents","inputClass","cssProps","touchSelect","touchCallout","contentZooming","userDrag","tapHighlightColor","handlers","oldCssProps","toggleCssProps","stop","force","stopped","curRecognizer","existing","data","gestureEvent","createEvent","initEvent","gesture","dispatchEvent","triggerDomEvent","INPUT_MOVE","STATE_BEGAN","STATE_CHANGED","STATE_ENDED","STATE_RECOGNIZED","STATE_CANCELLED","Tap","Pan","Swipe","Pinch","Rotate","Press","MAX_SAFE_INTEGER","argsTag","funcTag","genTag","freeGlobal","g","freeSelf","Function","arrayPush","objectProto","objectToString","Symbol","propertyIsEnumerable","spreadableSymbol","isConcatSpreadable","nativeMax","max","baseFlatten","depth","isStrict","isFlattenable","isObjectLike","isLength","tag","isObject","isFunction","isArrayLike","isArrayLikeObject","isArguments","fromRight","flowRight","funcs","reverse","otherArgs","thisArg","HASH_UNDEFINED","asyncTag","nullTag","objectTag","proxyTag","undefinedTag","reIsHostCtor","reIsUint","typedArrayTags","freeExports","nodeType","freeModule","moduleExports","freeProcess","nodeUtil","require","binding","nodeIsTypedArray","isTypedArray","transform","arrayProto","funcProto","coreJsData","funcToString","maskSrcKey","IE_PROTO","nativeObjectToString","objectCtorString","reIsNative","Buffer","Uint8Array","allocUnsafe","getPrototype","getPrototypeOf","objectCreate","symToStringTag","toStringTag","defineProperty","getNative","nativeIsBuffer","isBuffer","nativeNow","Map","nativeCreate","baseCreate","object","proto","Hash","entry","ListCache","MapCache","Stack","__data__","size","arrayLikeKeys","inherited","isArg","isBuff","isType","skipIndexes","iteratee","baseTimes","String","isIndex","assignMergeValue","eq","baseAssignValue","assignValue","objValue","assocIndexOf","has","pop","getMapData","pairs","LARGE_ARRAY_SIZE","baseFor","keysFunc","iterable","baseGetTag","isOwn","unmasked","getRawTag","baseIsArguments","baseIsNative","isMasked","toSource","baseKeysIn","nativeKeysIn","isProto","isPrototype","baseMerge","srcIndex","customizer","srcValue","mergeFunc","safeGet","stacked","newValue","isCommon","isTyped","copyArray","buffer","isDeep","copy","cloneBuffer","typedArray","arrayBuffer","byteLength","byteOffset","isPlainObject","copyObject","keysIn","toPlainObject","initCloneObject","baseMergeDeep","baseRest","setToString","overRest","identity","baseSetToString","string","map","getValue","lastCalled","stamp","remaining","shortOut","other","baseUnary","assigner","sources","guard","isIterateeCall","mergeWith","symbolTag","arrayIncludes","fromIndex","baseFindIndex","baseIsNaN","baseIndexOf","arrayIncludesWith","arrayMap","cacheHas","cache","overArg","nativeGetSymbols","getOwnPropertySymbols","SetCache","pattern","isHostObject","getAllKeysIn","symbolsFunc","baseGetAllKeys","getSymbolsIn","getSymbols","stubArray","toKey","isSymbol","omit","basePickBy","basePick","includes","valuesLength","outer","computed","valuesIndex","baseDifference","strictUriEncode","decodeComponent","splitOnFirst","filterObject","validateArrayFormatSeparator","encode","strict","encodeURIComponent","keysSorter","removeHash","hashStart","extract","queryStart","parseValue","parseNumbers","parseBooleans","query","arrayFormat","arrayFormatSeparator","formatter","accumulator","isEncodedArray","parserForArrayFormat","param","reduce","shouldFilter","skipNull","skipEmptyString","encoderForArrayFormat","objectCopy","parseUrl","url","url_","hash","parseFragmentIdentifier","fragmentIdentifier","stringifyUrl","queryFromUrl","parsedQueryFromUrl","queryString","getHash","pick","exclude","exclusionFilter","extendStatics","__extends","d","setPrototypeOf","__proto__","__","__assign","s","rowSizeBase","width","height","cursor","colSizeBase","edgeBase","styles","bottom","topRight","bottomRight","bottomLeft","topLeft","Resizer","onMouseDown","onResizeStart","onTouchStart","render","replaceStyles","children","DEFAULT_SIZE","clamp","snap","hasDirection","dir","isTouchEvent","findClosestSnap","snapArray","snapGap","closestGapIndex","prev","curr","gap","getStringSize","endsWith","getPixelSize","parentSize","innerWidth","innerHeight","definedProps","baseClassName","Resizable","ratio","resizable","parentLeft","parentTop","resizableLeft","resizableRight","resizableTop","resizableBottom","targetLeft","targetTop","appendBase","flex","classList","removeBase","c","isResizing","propsSize","backgroundStyle","backgroundColor","opacity","zIndex","flexBasis","onMouseMove","onMouseUp","enumerable","configurable","defaultSize","orgWidth","offsetWidth","orgHeight","offsetHeight","orgPosition","getSize","getParentSize","wrapChanged","wrap","flexWrap","minWidth","minHeight","bindEvents","capture","passive","unbindEvents","componentDidMount","computedStyle","getComputedStyle","setState","componentWillUnmount","createSizeForCssProperty","newSize","kind","calculateNewMaxFromBoundary","maxWidth","maxHeight","boundWidth","boundHeight","boundsByDirection","widthByDirection","heightByDirection","bounds","parent_1","isFinite","calculateNewSizeFromDirection","resizeRatio","_a","_b","lockAspectRatio","lockAspectRatioExtraHeight","lockAspectRatioExtraWidth","newWidth","newHeight","extraHeight","extraWidth","calculateNewSizeFromAspectRatio","computedMinWidth","computedMaxWidth","computedMinHeight","computedMaxHeight","extraMinWidth","extraMaxWidth","extraMinHeight","extraMaxHeight","lockedMinWidth","lockedMaxWidth","lockedMinHeight","lockedMaxHeight","setBoundingClientRect","parent_2","parentRect","getBoundingClientRect","targetRect","top_1","nativeEvent","isMouseEvent","parent_3","flexDirection","flexDir","startsWith","TouchEvent","calculateNewMax","_c","boundaryMax","grid","newGridWidth","newGridHeight","delta","newState","flushSync","onResize","onResizeStop","updateSize","renderResizer","handleStyles","handleClasses","handleWrapperStyle","handleWrapperClass","handleComponent","resizers","extendsProps","acc","sizeStyle","boxSizing","flexShrink","Wrapper","as","defaultProps","q","r","u","z","B","aa","ba","D","ca","da","ea","fa","ha","ia","ja","ka","for","E","F","displayName","$$typeof","_context","_render","_payload","_init","la","__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED","ma","I","_threadCount","_currentValue2","J","Uint16Array","K","oa","pa","qa","ra","sa","M","f","h","acceptsBooleans","attributeName","attributeNamespace","mustUseProperty","propertyName","sanitizeURL","removeEmptyString","N","va","wa","xlinkHref","xa","O","charCodeAt","substring","ya","ta","ua","Aa","is","P","Q","R","S","T","U","V","W","Ba","memoizedState","queue","next","Ca","Da","Ea","Fa","Ga","dispatch","delete","action","Ha","Ia","Ja","X","Ka","readContext","threadID","useContext","useMemo","useReducer","useRef","current","useState","useLayoutEffect","useCallback","useImperativeHandle","useEffect","useDebugValue","useDeferredValue","useTransition","useOpaqueIdentifier","identifierPrefix","uniqueID","useMutableSource","_source","La","Ma","Na","area","br","col","embed","hr","img","keygen","link","meta","track","wbr","Oa","menuitem","Y","animationIterationCount","borderImageOutset","borderImageSlice","borderImageWidth","boxFlex","boxFlexGroup","boxOrdinalGroup","columnCount","columns","flexGrow","flexPositive","flexNegative","flexOrder","gridArea","gridRow","gridRowEnd","gridRowSpan","gridRowStart","gridColumn","gridColumnEnd","gridColumnSpan","gridColumnStart","fontWeight","lineClamp","lineHeight","order","orphans","tabSize","widows","zoom","fillOpacity","floodOpacity","stopOpacity","strokeDasharray","strokeDashoffset","strokeMiterlimit","strokeOpacity","strokeWidth","Pa","charAt","Qa","Ra","Z","Children","Sa","ReactCurrentDispatcher","Ta","listing","pre","textarea","Ua","Va","Wa","Ya","Za","dangerouslySetInnerHTML","suppressContentEditableWarning","suppressHydrationWarning","$a","ab","isReactComponent","contextType","contextTypes","na","isMounted","enqueueForceUpdate","enqueueReplaceState","enqueueSetState","getDerivedStateFromProps","updater","UNSAFE_componentWillMount","componentWillMount","H","getChildContext","childContextTypes","A","isValidElement","bb","domNamespace","childIndex","footer","exhausted","currentSelectValue","previousWasTextNode","makeStaticMarkup","suspenseDepth","contextIndex","contextStack","contextValueStack","clearProviders","pushProvider","popProvider","read","L","G","C","fallbackFrame","then","renderDOM","defaultChecked","defaultValue","checked","Xa","selected","w","__html","renderToString","Infinity","separator","separatorIndex","rangeCount","active","activeElement","ranges","getRangeAt","tagName","blur","focus","tryToString","$TypeError","IS_DENO","IS_NODE","Deno","anObject","isArrayIteratorMethod","lengthOfArrayLike","isPrototypeOf","getIterator","getIteratorMethod","iteratorClose","ResultPrototype","unboundFunction","iterFn","that","AS_ENTRIES","IS_RECORD","IS_ITERATOR","INTERRUPTED","condition","callFn","done","global","NativePromiseConstructor","isCallable","isForced","inspectSource","wellKnownSymbol","IS_BROWSER","IS_PURE","V8_VERSION","NativePromisePrototype","SPECIES","SUBCLASSING","NATIVE_PROMISE_REJECTION_EVENT","PromiseRejectionEvent","FORCED_PROMISE_CONSTRUCTOR","PROMISE_CONSTRUCTOR_SOURCE","GLOBAL_CORE_JS_PROMISE","promise","resolve","FakePromise","CONSTRUCTOR","REJECTION_EVENT","checkCorrectnessOfIteration","$","toObject","setArrayLength","deletePropertyOrThrow","doesNotExceedSafeInteger","arity","forced","writable","properErrorOnNonWritableLength","argCount","to","aCallable","newPromiseCapabilityModule","perform","iterate","stat","allSettled","capability","reject","promiseResolve","counter","alreadyCalled","status","reason","URL","useMenuItem","hideOnClick","preventScrollOnKeyDown","focusOnHover","blurOnHoverEnd","menuContext","menubarContext","onClickProp","onClick","hideOnClickProp","hideMenu","hideAll","isWithinMenu","defaultPrevented","currentTarget","getAttribute","contentElement","role","baseElement","items","getState","hasAttribute","expandedItem","_a2","expandedMenuId","expandedMenu","getElementById","querySelector","menuHasFocus","MenuItem","htmlProps","ctx","useTabScopedContext","useScopedContext","useTabProviderContext","useProviderContext","TabContextProvider","ContextProvider","TabScopedContextProvider","ScopedContextProvider","menu","useMenuContext","useMenuScopedContext","useMenuProviderContext","MenuContextProvider","MenuScopedContextProvider","createContext","createMenuStore","combobox","menubar","parentIsMenubar","syncState","composite","orientation","hovercard","placement","hideTimeout","initialState","initialFocus","defaultValues","mounted","hide","setInitialFocus","setValues","setValue","prevValue","nextValue","useMenuStore","useMenuStoreProps","createMenubarStore","focusLoop","useMenubarStore","useMenubarStoreProps","useMenubar","storeProp","orientationProp","virtualFocus","rtl","jsx","Menubar","useMenubarContext","useMenubarScopedContext","useMenubarProviderContext","MenubarScopedContextProvider","hasActiveItem","excludeElement","some","useMenuButton","focusable","accessibleWhenDisabled","showOnHover","parentMenu","parentMenubar","hasParentMenu","disabled","showMenu","setDisclosureElement","setAnchorElement","show","onFocusProp","onFocus","setAutoFocusOnShow","setActiveId","onKeyDownProp","onKeyDown","ArrowDown","ArrowUp","ArrowRight","ArrowLeft","getInitialFocus","isKeyboardClick","detail","open","div","parentContentElement","getShowOnHover","toggleOnClick","typeahead","MenuButton","MenuProvider","useMenuList","alwaysVisible","isHorizontal","isMenubarHorizontal","previous","id2","move","ariaLabelledBy","setId","label","disclosureElement","disclosure","useAriaLabelledBy","hidden","display","setContentElement","hasCombobox","useMenu","modal","modalProp","portal","hideOnEscape","autoFocusOnShow","hideOnHoverOutside","initialFocusRef","setInitialFocusRef","autoFocusOnShowState","cleaning","prevInitialFocusRef","_a3","_b2","isConnected","createRef","mayAutoFocusOnShow","canAutoFocusOnShow","preserveTabOrderAnchor","parentRole","requestAnimationFrame","backdrop","Menu","useTabList","TabList","useTabPanel","tabId","tabIdProp","getItem","getItemProp","hasTabbableChildren","setHasTabbableChildren","tabbable","nextItem","panels","selectedId","TabPanel","createTabStore","defaultSelectedId","selectOnMove","tab","activeId","tabItem","dimmed","renderedItems","tabItem2","tabs","state2","panel","renderItem","setSelectedId","useTabStore","updatePanels","useTabStoreProps","TabProvider","useTab","defaultId","panelId","shouldRegisterItem","Tab","cos","sin","acos","pow","crt","pi","tau","quart","nMax","nMin","MIN_SAFE_INTEGER","ZERO","utils","Tvalues","Cvalues","arcfn","derivativeFn","points","_3d","mt","mt2","t2","dCpts","computeWithRatios","ratios","f1","f2","f3","f4","derive","dpoints","dpt","between","approximately","precision","sum","ds","de","ts","te","lerp","v1","v2","pointToString","pointsToString","dx1","dy1","dx2","dy2","pos","parseFloat","dist","closest","LUT","point","mpos","mdist","abcratio","projectionratio","lli8","x1","y1","x2","y2","x3","y3","x4","y4","lli4","p3","p4","lli","makeline","Bezier","findbbox","sections","mx","my","MX","MY","bbox","mid","shapeintersections","s1","bbox1","s2","bbox2","curveIntersectionThreshold","bboxoverlap","intersections","a1","startcap","forward","back","endcap","a2","l1","virtual","l2","iss","intersects","c1","c2","makeshape","bpl","fpl","shape","getminmax","curve","align","line","tx","ty","roots","aligned","m1","m2","pb","pc","q2","discriminant","u1","mp3","phi","t1","sd","droots","curvature","d1","d2","kOnly","num","dnm","adk","dk","dd","qdsum","pk","nk","inflections","v3","trm","sq","b1","b2","dims","dim","expandbox","_bbox","pairiteration","c1b","c2b","_t1","_t2","cc1","cc2","pair","getccenter","dx1p","dy1p","dx2p","dy2p","mx1","my1","mx2","my2","mx1n","my1n","mx2n","my2n","arc","_","numberSort","PolyBezier","curves","valueOf","addCurve","coords","from","coordlen","newargs","higher","dimlen","_linear","_lut","quadraticFromPoints","abc","getABC","cubicFromPoints","selen","lx","ly","bx1","by1","bx2","by2","e1","e2","nc1","nc2","getUtils","toSVG","setRatios","verify","print","coordDigest","_print","computedirection","clockwise","derivative","um","getLUT","steps","lut","hits","project","ft","raise","np","pim","dderivative","normal","__normal3","__normal2","r1","r2","q1","hull","_p","pt","span","extrema","mfn","overlaps","lbbox","tbbox","nv","simple","n1","n2","segment","pass1","pass2","distanceFn","ov","rc","outline","d3","d4","reduced","fcurves","bcurves","alen","tlen","graduated","linearDistanceFunction","slen","fs","fe","bs","be","ls","le","segments","outlineshapes","shapes","lineIntersects","curveintersects","selfintersects","arcs","errorThreshold","_iterate","_error","np1","circles","safety","t_s","t_e","np2","np3","prev_arc","curr_good","prev_good","t_m","prev_e"],"sourceRoot":""}